Sven Van Caekenberghe wrote:
Hi,
User Herby Vojčík seems to have an issue with the --headless option on Windows
10
https://pharo.fogbugz.com/f/cases/20271/ZnServer-managedServers-disappear-when-headless-mode-used
I cannot reproduce his problem.
Maybe there are Windows users out there who can have a look and help him ?
Thx,
Sven
I changed ZnSingleThreadedServer >> stop: to this:
stop: unregister
"Stop me. I will stop listening on my port for incoming HTTP
connections.
If unregister is true, unregister me from the list of managed instances.
Does nothing when I am not running"
self isRunning ifFalse: [ ^ self ].
unregister ifTrue: [ Error signal: 'stop: true was sent to running
server!' ].
process terminate.
process := nil.
unregister ifTrue: [ self unregister ].
self closeDelegate.
self logStopped
As a result, different PharoDebug.log was generated (only in headless
case, of course), which shows the server was indeed saved with both
process and serverSocket being notNil.
Attached.
Herby
THERE_BE_DRAGONS_HERE
Error: stop: true was sent to running server!
25 July 2017 10:28:58.7226 pm
VM: Win32 - IX86 - 10.0 - CoInterpreter VMMaker.oscog-eem.2254 uuid:
4f2c2cce-f4a2-469a-93f1-97ed941df0ad Jul 20 2017
StackToRegisterMappingCogit VMMaker.oscog-eem.2252 uuid:
2f3e9b0e-ecd3-4adf-b092-cce2e2587a5c Jul 20 2017
VM: 201707201942 https://github.com/OpenSmalltalk/opensmalltalk-vm.git $ Date:
Thu Jul 20 12:42:21 2017 -0700 $ Plugins: 201707201942
https://github.com/OpenSmalltalk/opensmalltalk-vm.git $
Image: Pharo6.0 [Latest update: #60510]
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>stop:
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
unregister: true
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
ZnManagingMultiThreadedServer>>stop:
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
unregister: true
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
ZnManagingMultiThreadedServer(ZnServer)>>stop
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
[ :each | each start ] in [ self managedServers do: [ :each | each start ] ] in
[ :manager |
manager default currentSession
addDeferredStartupAction: [ self managedServers do: [ :each | each
start ] ] ] in ZnServer class>>startUp:
Receiver: ZnServer
Arguments and temporary variables:
resuming: true
manager: SessionManager
each: a ZnManagingMultiThreadedServer(running 4998)
Receiver's instance variables:
superclass: Object
methodDict: a
MethodDictionary(#authenticator->ZnServer>>#authenticator #authen...etc...
format: 65538
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: {ZnSingleThreadedServer}
name: #ZnServer
classPool: a Dictionary(#AlwaysRestart->true
#ManagedServers->an IdentitySet(a ...etc...
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Zinc-HTTP-Client-Server'
traitComposition: {}
localSelectors: nil
IdentitySet(Set)>>do:
Receiver: an IdentitySet(a ZnManagingMultiThreadedServer(running 4998))
Arguments and temporary variables:
aBlock: [ :each | each start ]
index: 3
each: a ZnManagingMultiThreadedServer(running 4998)
Receiver's instance variables:
tally: 1
array: an Array(nil nil a
ZnManagingMultiThreadedServer(running 4998) nil nil n...etc...
[ self managedServers do: [ :each | each start ] ] in [ :manager |
manager default currentSession
addDeferredStartupAction: [ self managedServers do: [ :each | each
start ] ] ] in ZnServer class>>startUp:
Receiver: ZnServer
Arguments and temporary variables:
resuming: true
manager: SessionManager
Receiver's instance variables:
superclass: Object
methodDict: a
MethodDictionary(#authenticator->ZnServer>>#authenticator #authen...etc...
format: 65538
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: {ZnSingleThreadedServer}
name: #ZnServer
classPool: a Dictionary(#AlwaysRestart->true
#ManagedServers->an IdentitySet(a ...etc...
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Zinc-HTTP-Client-Server'
traitComposition: {}
localSelectors: nil
BlockClosure>>cull:
Receiver: [ self managedServers do: [ :each | each start ] ]
Arguments and temporary variables:
anArg: true
Receiver's instance variables:
outerContext: [ :manager |
manager default currentSession
addDeferredStartupA...etc...
startpc: 83
numArgs: 0
WorkingSession>>executeDeferredStartupActions:
Receiver: a WorkingSession
Arguments and temporary variables:
resuming: true
action: [ self managedServers do: [ :each | each start
] ]
Receiver's instance variables:
manager: a SessionManager
deferredStartupActions: an OrderedCollection()
id: nil
creationTime: 2017-07-25T22:26:03.584862+02:00
WorkingSession>>runStartup:
Receiver: a WorkingSession
Arguments and temporary variables:
isImageStarting: true
Receiver's instance variables:
manager: a SessionManager
deferredStartupActions: an OrderedCollection()
id: nil
creationTime: 2017-07-25T22:26:03.584862+02:00
WorkingSession>>start:
Receiver: a WorkingSession
Arguments and temporary variables:
isImageStarting: true
Receiver's instance variables:
manager: a SessionManager
deferredStartupActions: an OrderedCollection()
id: nil
creationTime: 2017-07-25T22:26:03.584862+02:00
SessionManager>>snapshot:andQuit:
Receiver: a SessionManager
Arguments and temporary variables:
save: true
quit: false
isImageStarting: true
snapshotResult: true
Receiver's instance variables:
currentSession: a WorkingSession
categories: an OrderedCollection(a SessionCategory(System)
a SessionCategory(Ne...etc...
guiCategory: a SessionCategory(Graphical User Interface)
toolsCategory: a SessionCategory(Tools)
networkCategory: a SessionCategory(Network)
systemCategory: a SessionCategory(System)
userCategory: a SessionCategory(User)
[ ^ SessionManager default snapshot: save andQuit: quit ] in
SmalltalkImage>>snapshot:andQuit:
Receiver: Smalltalk
Arguments and temporary variables:
save: true
quit: false
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
CurrentExecutionEnvironment class>>activate:for:
Receiver: CurrentExecutionEnvironment
Arguments and temporary variables:
anExecutionEnvironment: a DefaultExecutionEnvironment
aBlock: [ ^ SessionManager default snapshot: save
andQuit: quit ]
current: nil
Receiver's instance variables:
superclass: ProcessLocalVariable
methodDict: a
MethodDictionary(#default->CurrentExecutionEnvironment>>#default ...etc...
format: 65537
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #CurrentExecutionEnvironment
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Kernel-Processes'
traitComposition: {}
localSelectors: nil
soleInstance: a CurrentExecutionEnvironment
DefaultExecutionEnvironment(ExecutionEnvironment)>>beActiveDuring:
Receiver: a DefaultExecutionEnvironment
Arguments and temporary variables:
aBlock: [ ^ SessionManager default snapshot: save
andQuit: quit ]
Receiver's instance variables:
a DefaultExecutionEnvironment
DefaultExecutionEnvironment class>>beActiveDuring:
Receiver: DefaultExecutionEnvironment
Arguments and temporary variables:
aBlock: [ ^ SessionManager default snapshot: save
andQuit: quit ]
Receiver's instance variables:
superclass: ExecutionEnvironment
methodDict: a
MethodDictionary(#prepareForNewProcess:->DefaultExecutionEnvironm...etc...
format: 0
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #DefaultExecutionEnvironment
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Kernel-Processes'
traitComposition: {}
localSelectors: nil
instance: a DefaultExecutionEnvironment
SmalltalkImage>>snapshot:andQuit:
Receiver: Smalltalk
Arguments and temporary variables:
save: true
quit: false
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
SmalltalkImage>>saveImageInFileNamed:
Receiver: Smalltalk
Arguments and temporary variables:
aFile: 'D:\Herby\Work\cinegames\towergame-backend\work.image'
imageFile: File @
D:\Herby\Work\cinegames\towergame-backend\work.image
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
SmalltalkImage>>saveAs:
Receiver: Smalltalk
Arguments and temporary variables:
newNameWithoutSuffix: 'work'
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
SaveCommandLineHandler>>saveImage
Receiver: a SaveCommandLineHandler
Arguments and temporary variables:
imageName: 'work'
oldImageFile: File @
D:\Herby\Work\cinegames\towergame-backend\base.image
oldChangesFile: File @
D:\Herby\Work\cinegames\towergame-backend\base.changes
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
SaveCommandLineHandler>>activate
Receiver: a SaveCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
SaveCommandLineHandler class(CommandLineHandler class)>>activateWith:
Receiver: SaveCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: CommandLineHandler
methodDict: a
MethodDictionary(#activate->SaveCommandLineHandler>>#activate #sa...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #SaveCommandLineHandler
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'System-BasicCommandLineHandler'
traitComposition: {}
localSelectors: nil
[ aCommandLinehandler activateWith: commandLine ] in
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: SaveCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BlockClosure>>on:do:
Receiver: [ aCommandLinehandler activateWith: commandLine ]
Arguments and temporary variables:
exception: Exit
handlerAction: [ :exit | ^ self handleExit: exit for:
aCommandLinehandler ]
Receiver's instance variables:
outerContext:
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubComm...etc...
startpc: 34
numArgs: 0
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: SaveCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler(BasicCommandLineHandler)>>handleSubcommand
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
handlers: an OrderedCollection(SaveCommandLineHandler)
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler(BasicCommandLineHandler)>>handleArgument:
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
aString: 'save'
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
[ self
handleArgument:
(self arguments
ifEmpty: [ '' ]
ifNotEmpty: [ :arguments | arguments first ]) ] in
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BlockClosure>>on:do:
Receiver: [ self
handleArgument:
(self arguments
ifEmpty: [ '' ]
ifNotEmpty: [ :arguments |...etc...
Arguments and temporary variables:
exception: Exit
handlerAction: [ :exit | ^ self handleExit: exit ]
Receiver's instance variables:
outerContext:
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
startpc: 49
numArgs: 0
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler>>activate
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler class(CommandLineHandler class)>>activateWith:
Receiver: PharoCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: BasicCommandLineHandler
methodDict: a
MethodDictionary(#activate->PharoCommandLineHandler>>#activate #c...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #PharoCommandLineHandler
classPool: a Dictionary()
sharedPools: nil
environment: a SystemDictionary(lots of globals)
category: #'System-CommandLineHandler'
traitComposition: {}
localSelectors: nil
[ super activateWith: aCommandLine ] in PharoCommandLineHandler
class>>activateWith:
Receiver: PharoCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: BasicCommandLineHandler
methodDict: a
MethodDictionary(#activate->PharoCommandLineHandler>>#activate #c...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #PharoCommandLineHandler
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'System-CommandLineHandler'
traitComposition: {}
localSelectors: nil
NonInteractiveUIManager(UIManager)>>defer:
Receiver: a NonInteractiveUIManager
Arguments and temporary variables:
aBlock: [ super activateWith: aCommandLine ]
Receiver's instance variables:
doNotQuitOnRestart: false
uiManager: nil
PharoCommandLineHandler class>>activateWith:
Receiver: PharoCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: BasicCommandLineHandler
methodDict: a
MethodDictionary(#activate->PharoCommandLineHandler>>#activate #c...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #PharoCommandLineHandler
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'System-CommandLineHandler'
traitComposition: {}
localSelectors: nil
[ aCommandLinehandler activateWith: commandLine ] in
BasicCommandLineHandler>>activateSubCommand:
Receiver: a BasicCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: PharoCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BlockClosure>>on:do:
Receiver: [ aCommandLinehandler activateWith: commandLine ]
Arguments and temporary variables:
exception: Exit
handlerAction: [ :exit | ^ self handleExit: exit for:
aCommandLinehandler ]
Receiver's instance variables:
outerContext: BasicCommandLineHandler>>activateSubCommand:
startpc: 34
numArgs: 0
BasicCommandLineHandler>>activateSubCommand:
Receiver: a BasicCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: PharoCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BasicCommandLineHandler>>handleSubcommand
Receiver: a BasicCommandLineHandler
Arguments and temporary variables:
handlers: an OrderedCollection(PharoCommandLineHandler
SaveCommandLineHandler)
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
--- The full stack ---
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>stop:
ZnManagingMultiThreadedServer>>stop:
ZnManagingMultiThreadedServer(ZnServer)>>stop
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
[ :each | each start ] in THERE_BE_DRAGONS_HERE
Error: stop: true was sent to running server!
25 July 2017 10:29:50.172455 pm
VM: Win32 - IX86 - 10.0 - CoInterpreter VMMaker.oscog-eem.2254 uuid:
4f2c2cce-f4a2-469a-93f1-97ed941df0ad Jul 20 2017
StackToRegisterMappingCogit VMMaker.oscog-eem.2252 uuid:
2f3e9b0e-ecd3-4adf-b092-cce2e2587a5c Jul 20 2017
VM: 201707201942 https://github.com/OpenSmalltalk/opensmalltalk-vm.git $ Date:
Thu Jul 20 12:42:21 2017 -0700 $ Plugins: 201707201942
https://github.com/OpenSmalltalk/opensmalltalk-vm.git $
Image: Pharo6.0 [Latest update: #60510]
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>stop:
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
unregister: true
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
ZnManagingMultiThreadedServer>>stop:
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
unregister: true
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
ZnManagingMultiThreadedServer(ZnServer)>>stop
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
Receiver: a ZnManagingMultiThreadedServer(running 4998)
Arguments and temporary variables:
Receiver's instance variables:
options: a Dictionary(#delegate->a TowergameDelegate
#port->4998 )
sessionManager: nil
process: a Process in [ self schedule.
"It is critical that the following has n...etc...
serverSocket: a Socket[waitingForConnection]
logLevel: 3
lock: nil
connections: an OrderedCollection()
[ :each | each start ] in [ self managedServers do: [ :each | each start ] ] in
[ :manager |
manager default currentSession
addDeferredStartupAction: [ self managedServers do: [ :each | each
start ] ] ] in ZnServer class>>startUp:
Receiver: ZnServer
Arguments and temporary variables:
resuming: true
manager: SessionManager
each: a ZnManagingMultiThreadedServer(running 4998)
Receiver's instance variables:
superclass: Object
methodDict: a
MethodDictionary(#authenticator->ZnServer>>#authenticator #authen...etc...
format: 65538
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: {ZnSingleThreadedServer}
name: #ZnServer
classPool: a Dictionary(#AlwaysRestart->true
#ManagedServers->an IdentitySet(a ...etc...
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Zinc-HTTP-Client-Server'
traitComposition: {}
localSelectors: nil
IdentitySet(Set)>>do:
Receiver: an IdentitySet(a ZnManagingMultiThreadedServer(running 4998))
Arguments and temporary variables:
aBlock: [ :each | each start ]
index: 3
each: a ZnManagingMultiThreadedServer(running 4998)
Receiver's instance variables:
tally: 1
array: an Array(nil nil a
ZnManagingMultiThreadedServer(running 4998) nil nil n...etc...
[ self managedServers do: [ :each | each start ] ] in [ :manager |
manager default currentSession
addDeferredStartupAction: [ self managedServers do: [ :each | each
start ] ] ] in ZnServer class>>startUp:
Receiver: ZnServer
Arguments and temporary variables:
resuming: true
manager: SessionManager
Receiver's instance variables:
superclass: Object
methodDict: a
MethodDictionary(#authenticator->ZnServer>>#authenticator #authen...etc...
format: 65538
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: {ZnSingleThreadedServer}
name: #ZnServer
classPool: a Dictionary(#AlwaysRestart->true
#ManagedServers->an IdentitySet(a ...etc...
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Zinc-HTTP-Client-Server'
traitComposition: {}
localSelectors: nil
BlockClosure>>cull:
Receiver: [ self managedServers do: [ :each | each start ] ]
Arguments and temporary variables:
anArg: true
Receiver's instance variables:
outerContext: [ :manager |
manager default currentSession
addDeferredStartupA...etc...
startpc: 83
numArgs: 0
WorkingSession>>executeDeferredStartupActions:
Receiver: a WorkingSession
Arguments and temporary variables:
resuming: true
action: [ self managedServers do: [ :each | each start
] ]
Receiver's instance variables:
manager: a SessionManager
deferredStartupActions: an OrderedCollection()
id: nil
creationTime: 2017-07-25T22:26:03.584862+02:00
WorkingSession>>runStartup:
Receiver: a WorkingSession
Arguments and temporary variables:
isImageStarting: true
Receiver's instance variables:
manager: a SessionManager
deferredStartupActions: an OrderedCollection()
id: nil
creationTime: 2017-07-25T22:26:03.584862+02:00
WorkingSession>>start:
Receiver: a WorkingSession
Arguments and temporary variables:
isImageStarting: true
Receiver's instance variables:
manager: a SessionManager
deferredStartupActions: an OrderedCollection()
id: nil
creationTime: 2017-07-25T22:26:03.584862+02:00
SessionManager>>snapshot:andQuit:
Receiver: a SessionManager
Arguments and temporary variables:
save: true
quit: false
isImageStarting: true
snapshotResult: true
Receiver's instance variables:
currentSession: a WorkingSession
categories: an OrderedCollection(a SessionCategory(System)
a SessionCategory(Ne...etc...
guiCategory: a SessionCategory(Graphical User Interface)
toolsCategory: a SessionCategory(Tools)
networkCategory: a SessionCategory(Network)
systemCategory: a SessionCategory(System)
userCategory: a SessionCategory(User)
[ ^ SessionManager default snapshot: save andQuit: quit ] in
SmalltalkImage>>snapshot:andQuit:
Receiver: Smalltalk
Arguments and temporary variables:
save: true
quit: false
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
CurrentExecutionEnvironment class>>activate:for:
Receiver: CurrentExecutionEnvironment
Arguments and temporary variables:
anExecutionEnvironment: a DefaultExecutionEnvironment
aBlock: [ ^ SessionManager default snapshot: save
andQuit: quit ]
current: nil
Receiver's instance variables:
superclass: ProcessLocalVariable
methodDict: a
MethodDictionary(#default->CurrentExecutionEnvironment>>#default ...etc...
format: 65537
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #CurrentExecutionEnvironment
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Kernel-Processes'
traitComposition: {}
localSelectors: nil
soleInstance: a CurrentExecutionEnvironment
DefaultExecutionEnvironment(ExecutionEnvironment)>>beActiveDuring:
Receiver: a DefaultExecutionEnvironment
Arguments and temporary variables:
aBlock: [ ^ SessionManager default snapshot: save
andQuit: quit ]
Receiver's instance variables:
a DefaultExecutionEnvironment
DefaultExecutionEnvironment class>>beActiveDuring:
Receiver: DefaultExecutionEnvironment
Arguments and temporary variables:
aBlock: [ ^ SessionManager default snapshot: save
andQuit: quit ]
Receiver's instance variables:
superclass: ExecutionEnvironment
methodDict: a
MethodDictionary(#prepareForNewProcess:->DefaultExecutionEnvironm...etc...
format: 0
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #DefaultExecutionEnvironment
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Kernel-Processes'
traitComposition: {}
localSelectors: nil
instance: a DefaultExecutionEnvironment
SmalltalkImage>>snapshot:andQuit:
Receiver: Smalltalk
Arguments and temporary variables:
save: true
quit: false
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
SmalltalkImage>>saveImageInFileNamed:
Receiver: Smalltalk
Arguments and temporary variables:
aFile: 'D:\Herby\Work\cinegames\towergame-backend\work.image'
imageFile: File @
D:\Herby\Work\cinegames\towergame-backend\work.image
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
SmalltalkImage>>saveAs:
Receiver: Smalltalk
Arguments and temporary variables:
newNameWithoutSuffix: 'work'
Receiver's instance variables:
globals: a SystemDictionary(lots of globals)
deferredStartupActions: an OrderedCollection()
specialObjectsArray: an Array(nil false true
#Processor->Processor Bitmap Small...etc...
session: an Object
vm: a VirtualMachine
SaveCommandLineHandler>>saveImage
Receiver: a SaveCommandLineHandler
Arguments and temporary variables:
imageName: 'work'
oldImageFile: File @
D:\Herby\Work\cinegames\towergame-backend\base.image
oldChangesFile: File @
D:\Herby\Work\cinegames\towergame-backend\base.changes
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
SaveCommandLineHandler>>activate
Receiver: a SaveCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
SaveCommandLineHandler class(CommandLineHandler class)>>activateWith:
Receiver: SaveCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: CommandLineHandler
methodDict: a
MethodDictionary(#activate->SaveCommandLineHandler>>#activate #sa...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #SaveCommandLineHandler
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'System-BasicCommandLineHandler'
traitComposition: {}
localSelectors: nil
[ aCommandLinehandler activateWith: commandLine ] in
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: SaveCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BlockClosure>>on:do:
Receiver: [ aCommandLinehandler activateWith: commandLine ]
Arguments and temporary variables:
exception: Exit
handlerAction: [ :exit | ^ self handleExit: exit for:
aCommandLinehandler ]
Receiver's instance variables:
outerContext:
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubComm...etc...
startpc: 34
numArgs: 0
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: SaveCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler(BasicCommandLineHandler)>>handleSubcommand
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
handlers: an OrderedCollection(SaveCommandLineHandler)
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler(BasicCommandLineHandler)>>handleArgument:
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
aString: 'save'
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
[ self
handleArgument:
(self arguments
ifEmpty: [ '' ]
ifNotEmpty: [ :arguments | arguments first ]) ] in
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BlockClosure>>on:do:
Receiver: [ self
handleArgument:
(self arguments
ifEmpty: [ '' ]
ifNotEmpty: [ :arguments |...etc...
Arguments and temporary variables:
exception: Exit
handlerAction: [ :exit | ^ self handleExit: exit ]
Receiver's instance variables:
outerContext:
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
startpc: 49
numArgs: 0
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler>>activate
Receiver: a PharoCommandLineHandler
Arguments and temporary variables:
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
PharoCommandLineHandler class(CommandLineHandler class)>>activateWith:
Receiver: PharoCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: BasicCommandLineHandler
methodDict: a
MethodDictionary(#activate->PharoCommandLineHandler>>#activate #c...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #PharoCommandLineHandler
classPool: a Dictionary()
sharedPools: nil
environment: a SystemDictionary(lots of globals)
category: #'System-CommandLineHandler'
traitComposition: {}
localSelectors: nil
[ super activateWith: aCommandLine ] in PharoCommandLineHandler
class>>activateWith:
Receiver: PharoCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: BasicCommandLineHandler
methodDict: a
MethodDictionary(#activate->PharoCommandLineHandler>>#activate #c...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #PharoCommandLineHandler
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'System-CommandLineHandler'
traitComposition: {}
localSelectors: nil
NonInteractiveUIManager(UIManager)>>defer:
Receiver: a NonInteractiveUIManager
Arguments and temporary variables:
aBlock: [ super activateWith: aCommandLine ]
Receiver's instance variables:
doNotQuitOnRestart: false
uiManager: nil
PharoCommandLineHandler class>>activateWith:
Receiver: PharoCommandLineHandler
Arguments and temporary variables:
aCommandLine: a CommandLineArguments
Receiver's instance variables:
superclass: BasicCommandLineHandler
methodDict: a
MethodDictionary(#activate->PharoCommandLineHandler>>#activate #c...etc...
format: 65540
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #PharoCommandLineHandler
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'System-CommandLineHandler'
traitComposition: {}
localSelectors: nil
[ aCommandLinehandler activateWith: commandLine ] in
BasicCommandLineHandler>>activateSubCommand:
Receiver: a BasicCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: PharoCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BlockClosure>>on:do:
Receiver: [ aCommandLinehandler activateWith: commandLine ]
Arguments and temporary variables:
exception: Exit
handlerAction: [ :exit | ^ self handleExit: exit for:
aCommandLinehandler ]
Receiver's instance variables:
outerContext: BasicCommandLineHandler>>activateSubCommand:
startpc: 34
numArgs: 0
BasicCommandLineHandler>>activateSubCommand:
Receiver: a BasicCommandLineHandler
Arguments and temporary variables:
aCommandLinehandler: PharoCommandLineHandler
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
BasicCommandLineHandler>>handleSubcommand
Receiver: a BasicCommandLineHandler
Arguments and temporary variables:
handlers: an OrderedCollection(PharoCommandLineHandler
SaveCommandLineHandler)
Receiver's instance variables:
commandLine: a CommandLineArguments
session: a WorkingSession
stdout: a VTermOutputDriver
stderr: a VTermOutputDriver
--- The full stack ---
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>stop:
ZnManagingMultiThreadedServer>>stop:
ZnManagingMultiThreadedServer(ZnServer)>>stop
ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
[ :each | each start ] in [ self managedServers do: [ :each | each start ] ] in
[ :manager |
manager default currentSession
addDeferredStartupAction: [ self managedServers do: [ :each | each
start ] ] ] in ZnServer class>>startUp:
IdentitySet(Set)>>do:
[ self managedServers do: [ :each | each start ] ] in [ :manager |
manager default currentSession
addDeferredStartupAction: [ self managedServers do: [ :each | each
start ] ] ] in ZnServer class>>startUp:
BlockClosure>>cull:
WorkingSession>>executeDeferredStartupActions:
WorkingSession>>runStartup:
WorkingSession>>start:
SessionManager>>snapshot:andQuit:
[ ^ SessionManager default snapshot: save andQuit: quit ] in
SmalltalkImage>>snapshot:andQuit:
CurrentExecutionEnvironment class>>activate:for:
DefaultExecutionEnvironment(ExecutionEnvironment)>>beActiveDuring:
DefaultExecutionEnvironment class>>beActiveDuring:
SmalltalkImage>>snapshot:andQuit:
SmalltalkImage>>saveImageInFileNamed:
SmalltalkImage>>saveAs:
SaveCommandLineHandler>>saveImage
SaveCommandLineHandler>>activate
SaveCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
PharoCommandLineHandler(BasicCommandLineHandler)>>handleSubcommand
PharoCommandLineHandler(BasicCommandLineHandler)>>handleArgument:
[ self
handleArgument:
(self arguments
ifEmpty: [ '' ]
ifNotEmpty: [ :arguments | arguments first ]) ] in
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
PharoCommandLineHandler>>activate
PharoCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ super activateWith: aCommandLine ] in PharoCommandLineHandler
class>>activateWith:
NonInteractiveUIManager(UIManager)>>defer:
PharoCommandLineHandler class>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in
BasicCommandLineHandler>>activateSubCommand:
BlockClosure>>on:do:
BasicCommandLineHandler>>activateSubCommand:
BasicCommandLineHandler>>handleSubcommand
- - - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - -
BasicCommandLineHandler>>handleArgument:
[ self
handleArgument:
(self arguments
ifEmpty: [ '' ]
ifNotEmpty: [ :arguments | arguments first ]) ] in
BasicCommandLineHandler>>activate
BlockClosure>>on:do:
BasicCommandLineHandler>>activate
[ self new activate ] in BasicCommandLineHandler class>>startUp:
BlockClosure>>cull:
WorkingSession>>executeDeferredStartupActions:
WorkingSession>>runStartup:
WorkingSession>>start:
SessionManager>>snapshot:andQuit:
[ ^ SessionManager default snapshot: save andQuit: quit ] in
SmalltalkImage>>snapshot:andQuit:
CurrentExecutionEnvironment class>>activate:for:
DefaultExecutionEnvironment(ExecutionEnvironment)>>beActiveDuring:
DefaultExecutionEnvironment class>>beActiveDuring:
SmalltalkImage>>snapshot:andQuit:
[ Smalltalk snapshot: true andQuit: true ] in WorldState class>>saveAndQuit
BlockClosure>>ensure:
CursorWithMask(Cursor)>>showWhile:
WorldState class>>saveAndQuit
[ | selArgCount |
"show cursor in case item opens a new MVC window"
(selArgCount := selector numArgs) = 0
ifTrue: [ target perform: selector ]
ifFalse: [ selArgCount = arguments size
ifTrue: [ target perform: selector withArguments:
arguments ]
ifFalse: [ target perform: selector withArguments:
(arguments copyWith: evt) ].
self showShortcut ].
self changed ] in ToggleMenuItemMorph(MenuItemMorph)>>invokeWithEvent:
BlockClosure>>ensure:
CursorWithMask(Cursor)>>showWhile:
ToggleMenuItemMorph(MenuItemMorph)>>invokeWithEvent:
ToggleMenuItemMorph(MenuItemMorph)>>mouseUp:
ToggleMenuItemMorph(MenuItemMorph)>>handleMouseUp:
MouseButtonEvent>>sentTo:
ToggleMenuItemMorph(Morph)>>handleEvent:
MorphicEventDispatcher>>dispatchDefault:with:
MorphicEventDispatcher>>handleMouseUp:
MouseButtonEvent>>sentTo:
[ ^ anEvent sentTo: self ] in MorphicEventDispatcher>>dispatchEvent:with:
BlockClosure>>ensure:
MorphicEventDispatcher>>dispatchEvent:with:
ToggleMenuItemMorph(Morph)>>processEvent:using:
MorphicEventDispatcher>>dispatchDefault:with:
MorphicEventDispatcher>>handleMouseUp:
MouseButtonEvent>>sentTo:
[ ^ anEvent sentTo: self ] in MorphicEventDispatcher>>dispatchEvent:with:
BlockClosure>>ensure:
MorphicEventDispatcher>>dispatchEvent:with:
MenuMorph(Morph)>>processEvent:using:
MenuMorph(Morph)>>processEvent:
MenuMorph>>handleFocusEvent:
[ ActiveHand := self.
ActiveEvent := anEvent.
result := focusHolder
handleFocusEvent: (anEvent transformedBy: (focusHolder transformedFrom:
self)) ] in HandMorph>>sendFocusEvent:to:clear:
BlockClosure>>on:do:
WorldMorph(PasteUpMorph)>>becomeActiveDuring:
HandMorph>>sendFocusEvent:to:clear:
HandMorph>>sendEvent:focus:clear:
HandMorph>>sendMouseEvent:
HandMorph>>handleEvent:
HandMorph>>processEventsFromQueue:
HandMorph>>processEvents
[ :h |
self activeHand: h.
h processEvents.
self activeHand: nil ] in WorldState>>doOneCycleNowFor:
Array(SequenceableCollection)>>do:
WorldState>>handsDo:
WorldState>>doOneCycleNowFor:
WorldState>>doOneCycleFor:
WorldMorph>>doOneCycle
WorldMorph class>>doOneCycle
[ [ WorldMorph doOneCycle.
Processor yield.
false ] whileFalse: [ ] ] in MorphicUIManager>>spawnNewProcess
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
-------------------------------------------------------------------------------
