[Glass] Error installing DevKit_345
BrunoBB
smalltalk at adinet.com.uy
Wed Feb 19 10:15:09 PST 2020
Hi,
After trying different options find on google the error still persist:
* Reinstall openssl
* Reinstall curl
* and others
Finally i copied the repo
(/home/gemstone/GsDevKit_home/shared/repos/pharo3.0/) from my GS 3.4.1 to my
new GS 3.4.5 installation and that solved this particular issue.
It seems that there is problem with ../GsDevKit_home/shared/repos/pharo3.0/
repo.
(because it is the only repo causing a problem).
After this workaround GS 3.4.5 was installed sucessfully !!!
The PharoDebug.log with the stack attached below:
===============================================================================
Notice: Errors in script loaded from
/home/gemstone/GsDevKit_home/sys/default/pharo/gsDevKitCommandLineLoad.st
===============================================================================
THERE_BE_DRAGONS_HERE
ConnectionClosed: Connection closed while waiting for data.
19 February 2020 12:48:24.981077 pm
VM: unix - i686 - linux-gnu - NBCoInterpreter
NativeBoost-CogPlugin-GuillermoPolito.19 uuid:
acc98e51-2fba-4841-a965-2975997bba66 May 15 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid:
acc98e51-2fba-4841-a965-2975997bba66 May 15 2014
https://github.com/pharo-project/pharo-vm.git Commit:
ed4a4f59208968a21d82fd2406f75c2c4de558b2 Date: 2014-05-15 18:23:04 +0200 By:
Esteban Lorenzano <estebanlm at gmail.com> Jenkins build #14826
Image: Pharo3.0 [Latest update: #30864]
[ ConnectionClosed signal: 'Connection closed while waiting for data.' ] in
Socket>>waitForDataFor:
Receiver: a Socket[otherEndClosedButNotThisEnd]
Arguments and temporary variables:
timeout: 30
Receiver's instance variables:
semaphore: a Semaphore()
socketHandle: #[184 22 94 94 0 0 0 0 88 216 33 10]
readSemaphore: a Semaphore()
writeSemaphore: a Semaphore()
Socket>>waitForDataFor:ifClosed:ifTimedOut:
Receiver: a Socket[otherEndClosedButNotThisEnd]
Arguments and temporary variables:
timeout: 30
closedBlock: [ ConnectionClosed signal: 'Connection closed while waiting
for da...etc...
timedOutBlock: [ ConnectionTimedOut signal: 'Data receive timed out.' ]
startTime: 1507
msecsDelta: 30000
Receiver's instance variables:
semaphore: a Semaphore()
socketHandle: #[184 22 94 94 0 0 0 0 88 216 33 10]
readSemaphore: a Semaphore()
writeSemaphore: a Semaphore()
Socket>>waitForDataFor:
Receiver: a Socket[otherEndClosedButNotThisEnd]
Arguments and temporary variables:
timeout: 30
Receiver's instance variables:
semaphore: a Semaphore()
socketHandle: #[184 22 94 94 0 0 0 0 88 216 33 10]
readSemaphore: a Semaphore()
writeSemaphore: a Semaphore()
ZdcSecureSocketStream(ZdcAbstractSocketStream)>>socketWaitForData
Receiver: a ZdcSecureSocketStream
Arguments and temporary variables:
Receiver's instance variables:
socket: a Socket[otherEndClosedButNotThisEnd]
readBuffer: a ZdcIOBuffer(#[] +16384)
writeBuffer: a ZdcIOBuffer(#[] +4096)
timeout: 30
debug: false
sslSession: a ZdcPluginSSLSession
in: #[21 3 1 0 2 2 70 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0...etc...
out: #[22 3 1 0 67 1 0 0 63 3 1 94 77 116 232 243 171 9 0 212 73 71 143
161 142...etc...
connecting: true
ZdcSecureSocketStream>>readEncryptedBytes:startingAt:count:
Receiver: a ZdcSecureSocketStream
Arguments and temporary variables:
bytes: #[21 3 1 0 2 2 70 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 ...etc...
offset: 1
count: 4096
result: 0
Receiver's instance variables:
socket: a Socket[otherEndClosedButNotThisEnd]
readBuffer: a ZdcIOBuffer(#[] +16384)
writeBuffer: a ZdcIOBuffer(#[] +4096)
timeout: 30
debug: false
sslSession: a ZdcPluginSSLSession
in: #[21 3 1 0 2 2 70 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0...etc...
out: #[22 3 1 0 67 1 0 0 63 3 1 94 77 116 232 243 171 9 0 212 73 71 143
161 142...etc...
connecting: true
ZdcSecureSocketStream>>connect
Receiver: a ZdcSecureSocketStream
Arguments and temporary variables:
count: 7
result: -1
Receiver's instance variables:
socket: a Socket[otherEndClosedButNotThisEnd]
readBuffer: a ZdcIOBuffer(#[] +16384)
writeBuffer: a ZdcIOBuffer(#[] +4096)
timeout: 30
debug: false
sslSession: a ZdcPluginSSLSession
in: #[21 3 1 0 2 2 70 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0...etc...
out: #[22 3 1 0 67 1 0 0 63 3 1 94 77 116 232 243 171 9 0 212 73 71 143
161 142...etc...
connecting: true
ZnNetworkingUtils>>socketStreamToUrlDirectly:
Receiver: a ZnNetworkingUtils
Arguments and temporary variables:
url: https://github.com:443/dalehenrich/filetree/zipball/pharo3.0
stream: a ZdcSecureSocketStream
address: #[18 231 5 6]
Receiver's instance variables:
socketStreamClass: ZdcSocketStream
secureSocketStreamClass: ZdcSecureSocketStream
ZnNetworkingUtils>>socketStreamToUrl:
Receiver: a ZnNetworkingUtils
Arguments and temporary variables:
url: https://github.com:443/dalehenrich/filetree/zipball/pharo3.0
Receiver's instance variables:
socketStreamClass: ZdcSocketStream
secureSocketStreamClass: ZdcSecureSocketStream
ZnNetworkingUtils class>>socketStreamToUrl:
Receiver: ZnNetworkingUtils
Arguments and temporary variables:
url: https://github.com:443/dalehenrich/filetree/zipball/pharo3.0
Receiver's instance variables:
superclass: Object
methodDict: a
MethodDictionary(#bufferSize->ZnNetworkingUtils>>#bufferSize #htt...etc...
format: 134
layout: a FixedLayout
instanceVariables: #('socketStreamClass' 'secureSocketStreamClass')
organization: a ClassOrganization
subclasses: nil
name: #ZnNetworkingUtils
classPool: a Dictionary(#Default->a ZnNetworkingUtils
#DefaultSocketStreamTimeo...etc...
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Zinc-HTTP-Support'
traitComposition: {}
localSelectors: nil
ZnClient>>getConnectionAndExecute
Receiver: a ZnClient
Arguments and temporary variables:
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
ZnClient>>executeWithRedirectsRemaining:
Receiver: a ZnClient
Arguments and temporary variables:
redirectCount: 3
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
[ self executeWithRedirectsRemaining: self maxNumberOfRedirects ] in
ZnClient>>executeWithRetriesRemaining:
Receiver: a ZnClient
Arguments and temporary variables:
retryCount: 0
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
BlockClosure>>on:do:
Receiver: [ self executeWithRedirectsRemaining: self maxNumberOfRedirects ]
Arguments and temporary variables:
exception: an ExceptionSet
handlerAction: [ :exception |
retryCount > 0
ifTrue: [
self
handleRetry...etc...
handlerActive: false
Receiver's instance variables:
outerContext: ZnClient>>executeWithRetriesRemaining:
startpc: 69
numArgs: 0
ZnClient>>executeWithRetriesRemaining:
Receiver: a ZnClient
Arguments and temporary variables:
retryCount: 0
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
[ self executeWithRetriesRemaining: self numberOfRetries ] in [
[ self executeWithRetriesRemaining: self numberOfRetries ]
on: Error
do: self ifFailBlock ] in ZnClient>>executeWithTimeout
Receiver: a ZnClient
Arguments and temporary variables:
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
BlockClosure>>on:do:
Receiver: [ self executeWithRetriesRemaining: self numberOfRetries ]
Arguments and temporary variables:
exception: Error
handlerAction: [ :exception | exception pass ]
handlerActive: false
Receiver's instance variables:
outerContext: [
[ self executeWithRetriesRemaining: self numberOfRetries ]
on...etc...
startpc: 46
numArgs: 0
[
[ self executeWithRetriesRemaining: self numberOfRetries ]
on: Error
do: self ifFailBlock ] in ZnClient>>executeWithTimeout
Receiver: a ZnClient
Arguments and temporary variables:
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
[ ^ block value ] in ZnClient>>withTimeoutDo:
Receiver: a ZnClient
Arguments and temporary variables:
block: [
[ self executeWithRetriesRemaining: self numberOfRetries ]
on: Error...etc...
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
[
p psValueAt: index put: anObject.
aBlock value ] in ZnConnectionTimeout(DynamicVariable)>>value:during:
Receiver: a ZnConnectionTimeout
Arguments and temporary variables:
anObject: 30
aBlock: [ ^ block value ]
p: a Process in nil
oldValue: nil
Receiver's instance variables:
index: 1
BlockClosure>>ensure:
Receiver: [
p psValueAt: index put: anObject.
aBlock value ]
Arguments and temporary variables:
aBlock: [ p psValueAt: index put: oldValue ]
complete: nil
returnValue: nil
Receiver's instance variables:
outerContext: ZnConnectionTimeout(DynamicVariable)>>value:during:
startpc: 62
numArgs: 0
ZnConnectionTimeout(DynamicVariable)>>value:during:
Receiver: a ZnConnectionTimeout
Arguments and temporary variables:
anObject: 30
aBlock: [ ^ block value ]
p: a Process in nil
oldValue: nil
Receiver's instance variables:
index: 1
ZnConnectionTimeout class(DynamicVariable class)>>value:during:
Receiver: ZnConnectionTimeout
Arguments and temporary variables:
anObject: 30
aBlock: [ ^ block value ]
Receiver's instance variables:
superclass: DynamicVariable
methodDict: a MethodDictionary()
format: 132
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #ZnConnectionTimeout
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Zinc-HTTP-Variables'
traitComposition: {}
localSelectors: nil
hash: 972029952
soleInstance: a ZnConnectionTimeout
ZnClient>>withTimeoutDo:
Receiver: a ZnClient
Arguments and temporary variables:
block: [
[ self executeWithRetriesRemaining: self numberOfRetries ]
on: Error...etc...
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
ZnClient>>executeWithTimeout
Receiver: a ZnClient
Arguments and temporary variables:
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
[ result := self executeWithTimeout ] in ZnClient>>execute
Receiver: a ZnClient
Arguments and temporary variables:
initialMilliseconds: 1374
result: nil
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
[ ^ block value ] in ZnClient>>withProgressDo:
Receiver: a ZnClient
Arguments and temporary variables:
block: [ result := self executeWithTimeout ]
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
[
p psValueAt: index put: anObject.
aBlock value ] in ZnSignalProgress(DynamicVariable)>>value:during:
Receiver: a ZnSignalProgress
Arguments and temporary variables:
anObject: false
aBlock: [ ^ block value ]
p: a Process in nil
oldValue: nil
Receiver's instance variables:
index: 2
BlockClosure>>ensure:
Receiver: [
p psValueAt: index put: anObject.
aBlock value ]
Arguments and temporary variables:
aBlock: [ p psValueAt: index put: oldValue ]
complete: nil
returnValue: nil
Receiver's instance variables:
outerContext: ZnSignalProgress(DynamicVariable)>>value:during:
startpc: 62
numArgs: 0
ZnSignalProgress(DynamicVariable)>>value:during:
Receiver: a ZnSignalProgress
Arguments and temporary variables:
anObject: false
aBlock: [ ^ block value ]
p: a Process in nil
oldValue: nil
Receiver's instance variables:
index: 2
ZnSignalProgress class(DynamicVariable class)>>value:during:
Receiver: ZnSignalProgress
Arguments and temporary variables:
anObject: false
aBlock: [ ^ block value ]
Receiver's instance variables:
superclass: DynamicVariable
methodDict: a MethodDictionary()
format: 132
layout: a FixedLayout
instanceVariables: nil
organization: a ClassOrganization
subclasses: nil
name: #ZnSignalProgress
classPool: a Dictionary()
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Zinc-HTTP-Variables'
traitComposition: {}
localSelectors: nil
hash: nil
soleInstance: a ZnSignalProgress
ZnClient>>withProgressDo:
Receiver: a ZnClient
Arguments and temporary variables:
block: [ result := self executeWithTimeout ]
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
ZnClient>>execute
Receiver: a ZnClient
Arguments and temporary variables:
result: nil
initialMilliseconds: 1374
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
ZnClient>>get
Receiver: a ZnClient
Arguments and temporary variables:
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
ZnClient>>downloadTo:
Receiver: a ZnClient
Arguments and temporary variables:
path: '/tmp/github-dalehenrichfiletreepharo30.zip'
Receiver's instance variables:
request: a ZnRequest(GET /dalehenrich/filetree/zipball/pharo3.0)
response: nil
connection: nil
lastUsed: nil
options: a Dictionary(#streaming->true )
session: nil
log: nil
MetacelloPharo30Platform>>downloadFile:to:
Receiver: a MetacelloPharo30Platform
Arguments and temporary variables:
url: 'https://github.com/dalehenrich/filetree/zipball/pharo3.0'
outputFileName: '/tmp/github-dalehenrichfiletreepharo30.zip'
Receiver's instance variables:
bypassProgressBars: false
bypassGoferLoadUpdateCategories: false
MCGitHubRepository class>>projectDirectoryFrom:version:
Receiver: MCGitHubRepository
Arguments and temporary variables:
projectPath: 'dalehenrich/filetree'
versionString: 'pharo3.0'
mcPlatform: a MetacelloPharo30Platform
githubCacheDirectory: File @
/home/gemstone/GsDevKit_home/shared/pharo/github-c...etc...
projectDirectory: nil
downloadCacheKey: 'dalehenrich/filetree:::pharo3.0'
cachePath: nil
url: 'https://github.com/dalehenrich/filetree/zipball/pharo3.0'
archive: nil
directory: nil
zipFileName: '/tmp/github-dalehenrichfiletreepharo30.zip'
Receiver's instance variables:
superclass: MCFileTreeRepository
methodDict: a
MethodDictionary(#asRepositorySpecFor:->MCGitHubRepository>>#asRe...etc...
format: 152
layout: a FixedLayout
instanceVariables: #(#projectPath #projectVersion #repoPath)
organization: a ClassOrganization
subclasses: nil
name: #MCGitHubRepository
classPool: a Dictionary(#CacheDirectory->File @
/home/gemstone/GsDevKit_home/sh...etc...
sharedPools: an OrderedCollection()
environment: a SystemDictionary(lots of globals)
category: #'Metacello-GitHub'
traitComposition: {}
localSelectors: nil
defaultPackageExtension: nil
defaultPropertyFileExtension: nil
MCGitHubRepository>>directory
Receiver: a
MCGitHubRepository(github://dalehenrich/filetree:pharo3.0/repository)
Arguments and temporary variables:
Receiver's instance variables:
creationTemplate: nil
storeDiffs: nil
cache: nil
allFileNames: nil
cacheFileNames: nil
directory: nil
readonly: true
repositoryProperties: nil
projectPath: 'dalehenrich/filetree'
projectVersion: 'pharo3.0'
repoPath: 'repository'
MCGitHubRepository(MCFileTreeRepository)>>allFileNames
Receiver: a
MCGitHubRepository(github://dalehenrich/filetree:pharo3.0/repository)
Arguments and temporary variables:
Receiver's instance variables:
creationTemplate: nil
storeDiffs: nil
cache: nil
allFileNames: nil
cacheFileNames: nil
directory: nil
readonly: true
repositoryProperties: nil
projectPath: 'dalehenrich/filetree'
projectVersion: 'pharo3.0'
repoPath: 'repository'
MCGitHubRepository(MCFileBasedRepository)>>readableFileNames
Receiver: a
MCGitHubRepository(github://dalehenrich/filetree:pharo3.0/repository)
Arguments and temporary variables:
all: nil
cached: nil
new: nil
emptyFilenamelength: 9
Receiver's instance variables:
creationTemplate: nil
storeDiffs: nil
cache: nil
allFileNames: nil
cacheFileNames: nil
directory: nil
readonly: true
repositoryProperties: nil
projectPath: 'dalehenrich/filetree'
projectVersion: 'pharo3.0'
repoPath: 'repository'
--- The full stack ---
[ ConnectionClosed signal: 'Connection closed while waiting for data.' ] in
Socket>>waitForDataFor:
Socket>>waitForDataFor:ifClosed:ifTimedOut:
Socket>>waitForDataFor:
ZdcSecureSocketStream(ZdcAbstractSocketStream)>>socketWaitForData
ZdcSecureSocketStream>>readEncryptedBytes:startingAt:count:
ZdcSecureSocketStream>>connect
ZnNetworkingUtils>>socketStreamToUrlDirectly:
ZnNetworkingUtils>>socketStreamToUrl:
ZnNetworkingUtils class>>socketStreamToUrl:
ZnClient>>getConnectionAndExecute
ZnClient>>executeWithRedirectsRemaining:
[ self executeWithRedirectsRemaining: self maxNumberOfRedirects ] in
ZnClient>>executeWithRetriesRemaining:
BlockClosure>>on:do:
ZnClient>>executeWithRetriesRemaining:
[ self executeWithRetriesRemaining: self numberOfRetries ] in [
[ self executeWithRetriesRemaining: self numberOfRetries ]
on: Error
do: self ifFailBlock ] in ZnClient>>executeWithTimeout
BlockClosure>>on:do:
[
[ self executeWithRetriesRemaining: self numberOfRetries ]
on: Error
do: self ifFailBlock ] in ZnClient>>executeWithTimeout
[ ^ block value ] in ZnClient>>withTimeoutDo:
[
p psValueAt: index put: anObject.
aBlock value ] in ZnConnectionTimeout(DynamicVariable)>>value:during:
BlockClosure>>ensure:
ZnConnectionTimeout(DynamicVariable)>>value:during:
ZnConnectionTimeout class(DynamicVariable class)>>value:during:
ZnClient>>withTimeoutDo:
ZnClient>>executeWithTimeout
[ result := self executeWithTimeout ] in ZnClient>>execute
[ ^ block value ] in ZnClient>>withProgressDo:
[
p psValueAt: index put: anObject.
aBlock value ] in ZnSignalProgress(DynamicVariable)>>value:during:
BlockClosure>>ensure:
ZnSignalProgress(DynamicVariable)>>value:during:
ZnSignalProgress class(DynamicVariable class)>>value:during:
ZnClient>>withProgressDo:
ZnClient>>execute
ZnClient>>get
ZnClient>>downloadTo:
MetacelloPharo30Platform>>downloadFile:to:
MCGitHubRepository class>>projectDirectoryFrom:version:
MCGitHubRepository>>directory
MCGitHubRepository(MCFileTreeRepository)>>allFileNames
MCGitHubRepository(MCFileBasedRepository)>>readableFileNames
- - - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - -
MCGitHubRepository(MCFileBasedRepository)>>allVersionNames
[ self allVersionNames ] in
MCGitHubRepository(MCFileBasedRepository)>>goferReferences
BlockClosure>>on:do:
MCGitHubRepository(MCFileBasedRepository)>>goferReferences
[ aRepository goferReferences asSortedCollection asArray ] in
MetacelloGofer(Gofer)>>basicReferencesIn:
BlockClosure>>on:do:
MetacelloGofer(Gofer)>>basicReferencesIn:
MetacelloGofer>>basicReferencesIn:
[ self basicReferencesIn: aRepository ] in
MetacelloGofer(Gofer)>>allResolvedIn:
[ self at: key put: aBlock value ] in Dictionary>>at:ifAbsentPut:
Dictionary>>at:ifAbsent:
Dictionary>>at:ifAbsentPut:
MetacelloGofer(Gofer)>>allResolvedIn:
[ :repository | resolved addAll: (self allResolvedIn: repository) ] in
MetacelloGofer(Gofer)>>allResolved
Array(SequenceableCollection)>>do:
MetacelloGofer(Gofer)>>allResolved
GoferPackageReference(GoferReference)>>resolveAllWith:
MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>resolvePackageSpecReferences:gofer:
[ self resolvePackageSpecReferences: packageSpec gofer: gofer ] in
MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>retryingResolvePackageSpecReferences:gofer:
BlockClosure>>on:do:
MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>retryingResolvePackageSpecReferences:gofer:
linearLoadPackageSpec: packageSpec gofer: gofer
MetacelloPlatform current
do: [
| references nearestReference cachedReference externalReference mcVersion
loadedVersionInfos |
"check to see if mcz file is already in cacheRepository"
cachedReference := self resolvePackageSpec: packageSpec cachedGofer: self
loaderPolicy cacheGofer.
(cachedReference ~~ nil and: [ packageSpec getFile ~~ nil ])
ifTrue: [
cachedReference name = packageSpec file
ifTrue: [
"exact match between packageSpec file and cache"
^ self scheduleFetchFor: packageSpec cachedReference: cachedReference
] ]. "look up mcz file"
references := self retryingResolvePackageSpecReferences: packageSpec
gofer: gofer.
nearestReference := references last asMetacelloCachingResolvedReference.
"If the mcz is already in the cacheRepository, no need to copy"
(cachedReference ~~ nil and: [ cachedReference name = nearestReference
name ])
ifTrue: [
"latest reference in repository matches cachedReference ... "
^ self scheduleFetchFor: packageSpec nearestReference: nearestReference
]. "If the mcz is already loaded into the image, no need to copy"
(self ignoreImage not and: [ (loadedVersionInfos := self ancestorsFor:
packageSpec) ~~ nil ])
ifTrue: [
loadedVersionInfos
do: [ :info |
info name = nearestReference name
ifTrue: [ ^ self ] ] ].
externalReference := (references select: [ :ref | ref name =
nearestReference name ]) first
asMetacelloCachingResolvedReference.
self repositoryMap at: externalReference name put: externalReference
repository.
(self
resolveDependencies: externalReference
nearest: nearestReference
into: (OrderedCollection with: nearestReference))
do: [ :reference |
| pSpec l |
mcVersion := reference version.
(l := (GoferVersionReference name: reference name) resolveAllWith: self
loaderPolicy cacheGofer) isEmpty
ifTrue: [
self cacheRepository storeVersion: mcVersion.
reference == nearestReference
ifTrue: [ pSpec := packageSpec ]
ifFalse: [
pSpec := packageSpec project packageSpec.
pSpec name: mcVersion package name ].
self loadData
addVersion: mcVersion
versionInfo: mcVersion info
resolvedReference: reference
packageSpec: pSpec ] ].
self scheduleFetchFor: packageSpec externalReference: externalReference ]
displaying: 'Fetching ' , packageSpec file in
MetacelloEnsureFetchingMCSpecLoader(MetacelloFetchingMCSpecLoader)>>linearLoadPackageSpec:gofer:
MetacelloPharo30Platform(MetacelloPlatform)>>do:displaying:
MetacelloEnsureFetchingMCSpecLoader(MetacelloFetchingMCSpecLoader)>>linearLoadPackageSpec:gofer:
MetacelloPackageSpec>>loadUsing:gofer:
[ :pkg | pkg loadUsing: self gofer: gofer ] in
MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>linearLoadPackageSpecs:repositories:
Array(SequenceableCollection)>>do:
MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>linearLoadPackageSpecs:repositories:
[ super linearLoadPackageSpecs: packageSpecs repositories: repositories ] in
MetacelloEnsureFetchingMCSpecLoader(MetacelloFetchingMCSpecLoader)>>explicitLoadPackageSpecs:repositories:
BlockClosure>>ensure:
MetacelloLoaderPolicy>>pushLoadDirective:during:
MetacelloLoaderPolicy>>pushExplicitLoadDirectivesDuring:for:
MetacelloEnsureFetchingMCSpecLoader(MetacelloFetchingMCSpecLoader)>>explicitLoadPackageSpecs:repositories:
MetacelloPackageSpec>>explicitLoadUsing:
MetacelloPackageSpec>>ensureLoadUsing:
MetacelloMCBaselineOfProjectSpec(MetacelloMCProjectSpec)>>ensureLoadUsing:
MetacelloMCBaselineOfProjectSpec(MetacelloMCProjectSpec)>>ensureLoadedForDevelopmentUsing:
[ :pkg |
pkg ensureLoadedForDevelopmentUsing: mcLoader.
mcLoader ignoreImage
ifFalse: [
(pkg compareCurrentVersion: self operator targetVersionStatus:
#(#allLoadedToSpec) using: mcLoader)
ifTrue: [ packages removeKey: pkg name ] ] ] in
MetacelloMCVersionSpecLoader>>load
Array(SequenceableCollection)>>do:
MetacelloMCVersionSpecLoader>>load
MetacelloMCVersion>>executeLoadFromArray:
[ :dict | ^ self executeLoadFromArray: anArray ] in [
self versionSpec loader: newLoader.
MetacelloPlatform current
useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
defaultDictionary: Dictionary new ] in [
[
self versionSpec loader: newLoader.
MetacelloPlatform current
useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
defaultDictionary: Dictionary new ]
ensure: [ self versionSpec loader: originalLoader ] ] in
MetacelloMCVersion>>fetchRequiredFromArray:
[ ^ aBlock value: dict ] in
MetacelloPharo30Platform(MetacelloPlatform)>>useStackCacheDuring:defaultDictionary:
BlockClosure>>on:do:
MetacelloPharo30Platform(MetacelloPlatform)>>useStackCacheDuring:defaultDictionary:
[
self versionSpec loader: newLoader.
MetacelloPlatform current
useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
defaultDictionary: Dictionary new ] in [
[
self versionSpec loader: newLoader.
MetacelloPlatform current
useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
defaultDictionary: Dictionary new ]
ensure: [ self versionSpec loader: originalLoader ] ] in
MetacelloMCVersion>>fetchRequiredFromArray:
BlockClosure>>ensure:
[
[
self versionSpec loader: newLoader.
MetacelloPlatform current
useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
defaultDictionary: Dictionary new ]
ensure: [ self versionSpec loader: originalLoader ] ] in
MetacelloMCVersion>>fetchRequiredFromArray:
MetacelloPharo30Platform(MetacelloPlatform)>>do:displaying:
MetacelloMCVersion>>fetchRequiredFromArray:
[
| fetchLoader |
fetchLoader := self fetchRequiredFromArray: (self defaultPackageNamesToLoad:
anArray).
MetacelloPlatform current do: [ fetchLoader doLoad ] displaying: 'Loading '
, displayString.
Transcript
cr;
show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
BlockClosure>>ensure:
MetacelloMCVersion>>doLoadRequiredFromArray:
Array(Collection)>>loadRequiredForMetacelloMCVersion:
MetacelloMCVersion>>load:
[
self
handleNotificationsForAction: [
| version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
do: [ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade:
onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
root:
(required isEmpty
ifTrue: [ version load ]
ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
registrationForProjectSpec: loadedSpec
ifAbsent: [ :new |
new
loadedInImage: true;
registerProject ]
ifPresent: [ :existing :new |
existing
copyOnWrite: [ :existingCopy |
existingCopy
loadedInImage: true;
merge: new ] ] ] ] in [
self
handleNotificationsForAction: [
| version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
do: [ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade:
onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
root:
(required isEmpty
ifTrue: [ version load ]
ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
registrationForProjectSpec: loadedSpec
ifAbsent: [ :new |
new
loadedInImage: true;
registerProject ]
ifPresent: [ :existing :new |
existing
copyOnWrite: [ :existingCopy |
existingCopy
loadedInImage: true;
merge: new ] ] ] ] in
MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>on:do:
[
actionBlock
on:
MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad ,
MetacelloProjectSpecLoadedNotification
, MetacelloScriptEnsureProjectLoadedForDevelopment ,
MetacelloLookupBaselineSpecForEnsureLoad
do: [ :ex |
"lookup and registration handlers need to be innermost set of handlers
...they may throw option notifications"
ex handleResolutionFor: self ] ] in [
[
actionBlock
on:
MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad ,
MetacelloProjectSpecLoadedNotification
, MetacelloScriptEnsureProjectLoadedForDevelopment ,
MetacelloLookupBaselineSpecForEnsureLoad
do: [ :ex |
"lookup and registration handlers need to be innermost set of handlers
...they may throw option notifications"
ex handleResolutionFor: self ] ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade ,
MetacelloAllowConflictingProjectUpgrade
do: [ :ex |
"option handlers need to be outermost set of handlers ... last line of
defense before users are involved"
ex handleResolutionFor: self ] ] in [
[
[
actionBlock
on:
MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad ,
MetacelloProjectSpecLoadedNotification
, MetacelloScriptEnsureProjectLoadedForDevelopment ,
MetacelloLookupBaselineSpecForEnsureLoad
do: [ :ex |
"lookup and registration handlers need to be innermost set of handlers
...they may throw option notifications"
ex handleResolutionFor: self ] ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade ,
MetacelloAllowConflictingProjectUpgrade
do: [ :ex |
"option handlers need to be outermost set of handlers ... last line of
defense before users are involved"
ex handleResolutionFor: self ] ]
on: MetacelloAllowLockedProjectChange
do: [ :ex |
"MetacelloAllowLockedProjectChange need to be outermost handler ... since
it is signaled from second line of handlers"
ex handleResolutionFor: self ] ] in
MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[
[
actionBlock
on:
MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad ,
MetacelloProjectSpecLoadedNotification
, MetacelloScriptEnsureProjectLoadedForDevelopment ,
MetacelloLookupBaselineSpecForEnsureLoad
do: [ :ex |
"lookup and registration handlers need to be innermost set of handlers
...they may throw option notifications"
ex handleResolutionFor: self ] ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade ,
MetacelloAllowConflictingProjectUpgrade
do: [ :ex |
"option handlers need to be outermost set of handlers ... last line of
defense before users are involved"
ex handleResolutionFor: self ] ] in [
[
[
actionBlock
on:
MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad ,
MetacelloProjectSpecLoadedNotification
, MetacelloScriptEnsureProjectLoadedForDevelopment ,
MetacelloLookupBaselineSpecForEnsureLoad
do: [ :ex |
"lookup and registration handlers need to be innermost set of handlers
...they may throw option notifications"
ex handleResolutionFor: self ] ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade ,
MetacelloAllowConflictingProjectUpgrade
do: [ :ex |
"option handlers need to be outermost set of handlers ... last line of
defense before users are involved"
ex handleResolutionFor: self ] ]
on: MetacelloAllowLockedProjectChange
do: [ :ex |
"MetacelloAllowLockedProjectChange need to be outermost handler ... since
it is signaled from second line of handlers"
ex handleResolutionFor: self ] ] in
MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[
[
[
actionBlock
on:
MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad ,
MetacelloProjectSpecLoadedNotification
, MetacelloScriptEnsureProjectLoadedForDevelopment ,
MetacelloLookupBaselineSpecForEnsureLoad
do: [ :ex |
"lookup and registration handlers need to be innermost set of handlers
...they may throw option notifications"
ex handleResolutionFor: self ] ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade ,
MetacelloAllowConflictingProjectUpgrade
do: [ :ex |
"option handlers need to be outermost set of handlers ... last line of
defense before users are involved"
ex handleResolutionFor: self ] ]
on: MetacelloAllowLockedProjectChange
do: [ :ex |
"MetacelloAllowLockedProjectChange need to be outermost handler ... since
it is signaled from second line of handlers"
ex handleResolutionFor: self ] ] in
MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
MetacelloScriptEngine>>handleNotificationsForAction:
[
self
handleNotificationsForAction: [
| version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
do: [ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade:
onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
root:
(required isEmpty
ifTrue: [ version load ]
ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
registrationForProjectSpec: loadedSpec
ifAbsent: [ :new |
new
loadedInImage: true;
registerProject ]
ifPresent: [ :existing :new |
existing
copyOnWrite: [ :existingCopy |
existingCopy
loadedInImage: true;
merge: new ] ] ] ] in
MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>ensure:
MetacelloProjectRegistration class>>copyRegistryRestoreOnErrorWhile:
MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
MetacelloScriptEngine>>load:
[ :projectSpec |
| engine |
engine := MetacelloScriptEngine new
options: self options copy;
projectSpec: projectSpec;
yourself.
engine perform: actionArg key withArguments: actionArg value.
engine root ifNotNil: [ :root | self roots add: root ] ] in
MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
[ :projectSpec | projectSpec ifNotNil: [ projectSpecBlock value: (self
applyArgsToProjectSpec: projectSpec copy) ] ] in
MetacelloScriptApiExecutor>>executeString:do:
Array(SequenceableCollection)>>do:
MetacelloScriptApiExecutor>>executeString:do:
ByteString(String)>>execute:against:
MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
Metacello>>execute
Metacello>>load:
[
| todeClientRepo filetreeRepo metacelloRepo stonRepo todeRepo
smalltalkCIRepo |
filetreeRepo := Smalltalk os environment at:
'GS_SHARED_REPO_PHARO3_FILETREE'.
metacelloRepo := Smalltalk os environment at: 'GS_SHARED_REPO_METACELLO'.
stonRepo := Smalltalk os environment at: 'GS_SHARED_REPO_STON'.
todeRepo := Smalltalk os environment at: 'GS_SHARED_REPO_TODE'.
todeClientRepo := Smalltalk os environment at: 'GS_SHARED_REPO_TODE_CLIENT'.
smalltalkCIRepo := Smalltalk os environment at:
'GS_SHARED_REPO_SMALLTALKCI'.
Metacello new
baseline: 'FileTree';
repository: filetreeRepo;
lock.
Metacello new
baseline: 'Metacello';
repository: metacelloRepo;
get.
Metacello new
baseline: 'Metacello';
repository: metacelloRepo;
onConflict: [ :ex | ex allow ];
load: #('batch').
Metacello new
baseline: 'Ston';
repository: stonRepo;
lock;
get.
Metacello new
baseline: 'Tode';
repository: todeRepo;
lock;
get.
Metacello new
baseline: 'SmalltalkCI';
repository: smalltalkCIRepo;
lock;
get.
Metacello new
baseline: 'TodeClient';
repository: todeClientRepo;
get;
load: #('SmalltalkCI-CommandLine');
lock ] in UndefinedObject>>DoIt
BlockClosure>>on:do:
UndefinedObject>>DoIt
OpalCompiler>>evaluate
DoItDeclaration>>importFor:
[ :declaration |
requestor ifNotNil: [ requestor contents: declaration contents ].
value := declaration importFor: requestor ] in CodeImporter>>evaluate
OrderedCollection>>do:
CodeImporter>>evaluate
[ codeImporter evaluate ] in STCommandLineHandler>>installSourceFile:
BlockClosure>>on:do:
STCommandLineHandler>>handleErrorsDuring:reference:
STCommandLineHandler>>installSourceFile:
[ :reference | self installSourceFile: reference ] in [ sourceFiles do: [
:reference | self installSourceFile: reference ] ] in
STCommandLineHandler>>installSourceFiles
OrderedCollection>>do:
[ sourceFiles do: [ :reference | self installSourceFile: reference ] ] in
STCommandLineHandler>>installSourceFiles
BlockClosure>>ensure:
STCommandLineHandler>>installSourceFiles
STCommandLineHandler>>activate
STCommandLineHandler 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:
WorldState>>runStepMethodsIn:
WorldMorph>>runStepMethods
WorldState>>doOneCycleNowFor:
WorldState>>doOneCycleFor:
WorldMorph>>doOneCycle
[
World doOneCycle.
Processor yield.
false ] in MorphicUIManager>>spawnNewProcess
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
-------------------------------------------------------------------------------
Processes and their stacks:
Process: a Process in nil
stack:
Array(SequenceableCollection)>>do:
[ :logger |
logger
nextPutAll: 'Processes and their stacks: ';
cr.
Process allInstances
do: [ :each |
| ctx |
logger
nextPutAll: 'Process: ';
print: each;
cr;
nextPutAll: ' stack:';
cr;
cr.
ctx := each isActiveProcess
ifTrue: [ thisContext sender ]
ifFalse: [ each suspendedContext ].
ctx
ifNotNil: [
(ctx stackOfSize: 20)
do: [ :s |
logger
print: s;
cr ] ].
logger
nextPutAll: '------------------------------';
cr;
cr ] ] in [
Smalltalk logError: aString inContext: aContext. " Print stacks of all
current processes "
Smalltalk
logDuring: [ :logger |
logger
nextPutAll: 'Processes and their stacks: ';
cr.
Process allInstances
do: [ :each |
| ctx |
logger
nextPutAll: 'Process: ';
print: each;
cr;
nextPutAll: ' stack:';
cr;
cr.
ctx := each isActiveProcess
ifTrue: [ thisContext sender ]
ifFalse: [ each suspendedContext ].
ctx
ifNotNil: [
(ctx stackOfSize: 20)
do: [ :s |
logger
print: s;
cr ] ].
logger
nextPutAll: '------------------------------';
cr;
cr ] ] ] in
NonInteractiveUIManager(CommandLineUIManager)>>quitFrom:withMessage:
[
logStream := self openLog.
aMonadicBlock value: logStream ] in SmalltalkImage>>logDuring:
BlockClosure>>ensure:
SmalltalkImage>>logDuring:
[
Smalltalk logError: aString inContext: aContext. " Print stacks of all
current processes "
Smalltalk
logDuring: [ :logger |
logger
nextPutAll: 'Processes and their stacks: ';
cr.
Process allInstances
do: [ :each |
| ctx |
logger
nextPutAll: 'Process: ';
print: each;
cr;
nextPutAll: ' stack:';
cr;
cr.
ctx := each isActiveProcess
ifTrue: [ thisContext sender ]
ifFalse: [ each suspendedContext ].
ctx
ifNotNil: [
(ctx stackOfSize: 20)
do: [ :s |
logger
print: s;
cr ] ].
logger
nextPutAll: '------------------------------';
cr;
cr ] ] ] in
NonInteractiveUIManager(CommandLineUIManager)>>quitFrom:withMessage:
BlockClosure>>ensure:
NonInteractiveUIManager(CommandLineUIManager)>>quitFrom:withMessage:
NonInteractiveUIManager(CommandLineUIManager)>>unhandledErrorDefaultAction:
[ :class | class default unhandledErrorDefaultAction: self exception ] in
UnhandledError>>defaultAction
[ :v | ^ oneArgBlock value: v ] in
SystemDictionary(Dictionary)>>at:ifPresent:ifAbsent:
BlockClosure>>cull:
SystemDictionary(Dictionary)>>at:ifPresent:
SystemDictionary(Dictionary)>>at:ifPresent:ifAbsent:
UnhandledError>>defaultAction
UndefinedObject>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
------------------------------
Process: a Process in Delay class>>handleTimerEvent
stack:
Delay class>>handleTimerEvent
Delay class>>runTimerEventLoop
[ self runTimerEventLoop ] in Delay class>>startTimerEventLoop
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in [
self value.
Processor terminateActive ] in BlockClosure>>newProcess
stack:
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in [
self value.
Processor terminateActive ] in BlockClosure>>newProcess
stack:
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in [
self value.
Processor terminateActive ] in BlockClosure>>newProcess
stack:
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in [
self value.
Processor terminateActive ] in BlockClosure>>newProcess
stack:
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in InputEventFetcher>>waitForInput
stack:
InputEventFetcher>>waitForInput
InputEventFetcher>>eventLoop
[ self eventLoop ] in InputEventFetcher>>installEventLoop
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in SmalltalkImage>>lowSpaceWatcher
stack:
SmalltalkImage>>lowSpaceWatcher
[ self lowSpaceWatcher ] in SmalltalkImage>>installLowSpaceWatcher
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in ProcessorScheduler class>>idleProcess
stack:
ProcessorScheduler class>>idleProcess
[ self idleProcess ] in ProcessorScheduler class>>startUp
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
Process: a Process in WeakArray class>>finalizationProcess
stack:
WeakArray class>>finalizationProcess
[ self finalizationProcess ] in WeakArray class>>restartFinalizationProcess
[
self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------
--
Sent from: http://forum.world.st/GLASS-f1460844.html
More information about the Glass
mailing list