On 12-08-16 7:25 AM, Michael Haupt wrote:
> Craig,
>
> On 16 August 2012 03:30, Craig Latta <craig at netjam.org> wrote:
>> Please fire it up and let me know that it starts.
> the comment in the WormholeServer,
>
> "Connect to the minimal history and subject memories, and connect them
> to each other. Before evaluating this, start the 'history' and
> 'subject' memories.",
>
> suggests that I need to do something about those memories (start them
> up) before I evaluate the code following it.
>
> I'm a Spoon newbie. Likely I'm missing something obvious. What do I
> need to do? (Just evaluating the code hangs the system.)
>
> Best,
>
> Michael
> _______________________________________________
> Spoon mailing list
> Spoon at lists.squeakfoundation.org
> http://lists.squeakfoundation.org/cgi-bin/mailman/listinfo/spoon
On my Mac I do something like this:

Right click the package on your desktop. Choose "Show Package Contents". 
Then open the "Contents" folder. Then "Resources" in which you will find 
the subject.image and history.image. Start them by dragging them each 
over the Spoon icon in the dock, as you've already double clicked the 
main image to start.

Then you can proceed through the commands of the "a WormholeServer" 
inspector window to get an "Other Browser" which lets you see the 
contents of the subject.image. Unfortunately, when I execute the first 
few lines - #self down to #connect - to enage the ports, the image 
freezes. I press Command+. to get a user interrupt and I get an error as 
well. Or bell rings infinitely. I've attached the SqueakDebug.log 
output. Then I start Activity Monitor and force quit all three running 
images. I'm on Mac OSX 10.7.4.

HTH,
Chris

FailedReadingAttempt:
16 August 2012 7:54:47.685 am

VM: Mac OS - Smalltalk
Image: Squeak4.2 [latest update: #10966]

SecurityManager state:
Restricted: false
FileAccess: true
SocketAccess: true
Working Dir 
/Users/chriscunnington/Desktop/Spoon-3-alpha-4.app/Contents/Resources
Trusted Dir /foobar/tooBar/forSqueak/bogus
Untrusted Dir 
/Users/chriscunnington/Library/Preferences/Squeak/Internet/My Squeak

OutgoingClientTCPSocket(TCPSocket)>>next:from:into:startingAt:
     Receiver: an inactive OutgoingClientTCPSocket which was connected 
to port 62981 at localhost (127.0....etc...
     Arguments and temporary variables:
         bytesToReadInteger:     4
         tcpSocketHandle:     6828880
         targetByteArray:     #[0 0 0 0]
         targetStartIndex:     1
     Receiver's instance variables:
         handle:     6828880
         readability:     a Semaphore()
         writability:     a Semaphore()
         address:     port 62981 at localhost (127.0.0.1)
         peerClosed:     true

OutgoingClientTCPSocket(Peer)>>next:into:startingAt:timeoutAfter:
     Receiver: an inactive OutgoingClientTCPSocket which was connected 
to port 62981 at localhost (127.0....etc...
     Arguments and temporary variables:
         anInteger:     4
         aByteArray:     #[0 0 0 0]
         startIndex:     1
         numberOfMilliseconds:     nil
     Receiver's instance variables:
         handle:     6828880
         readability:     a Semaphore()
         writability:     a Semaphore()
         address:     port 62981 at localhost (127.0.0.1)
         peerClosed:     true

TCPStream(NetStream)>>next:into:startingAt:timeoutAfter:
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket 
which was connected to port 6298...etc...
     Arguments and temporary variables:
         numberOfElementsRequested:     4
         aSequenceableCollection:     #[0 0 0 0]
         startIndex:     1
         numberOfMilliseconds:     nil
         endIndex:     nil
         numberOfElementsConsumed:     #(0)
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was 
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

TCPStream(NetStream)>>next:timeoutAfter:
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket 
which was connected to port 6298...etc...
     Arguments and temporary variables:
         anInteger:     4
         numberOfMilliseconds:     nil
         elements:     nil
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was 
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

TCPStream(NetStream)>>next:
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket 
which was connected to port 6298...etc...
     Arguments and temporary variables:
         anInteger:     4
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was 
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

TCPStream(ExternalStream)>>nextWord
     Receiver: a binary TCPStream on an inactive OutgoingClientTCPSocket 
which was connected to port 6298...etc...
     Arguments and temporary variables:
         bytes:     nil
     Receiver's instance variables:
         collection:     #[]
         position:     0
         readLimit:     0
         writeLimit:     0
         resource:     an inactive OutgoingClientTCPSocket which was 
connected to port 62981...etc...
         binary:     true
         indexOfLastDirtyElement:     0
         singletonToWrite:     #[0]
         readingPositionLock:     a Semaphore()
         readingBufferSize:     0
         scarcityThreshold:     nil
         availability:     nil
         scarcity:     nil
         filling:     nil
         indexOfFirstWritableField:     nil
         transcribeTraffic:     false
         timeout:     nil
         writingPosition:     nil
         readingLimitLock:     nil
         transcript:     nil

Wormhole(MessagingSession)>>nextFrom:
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:
         aStream:     a binary TCPStream on an inactive 
OutgoingClientTCPSocket which was co...etc...
         tag:     nil
     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive 
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream 
connections at port 7...etc...
         processing:     a Process in Debugger 
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive 
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998, 
with no clients
         nextWormhole:     nil

Wormhole(MessagingSession)>>next
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:

     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive 
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream 
connections at port 7...etc...
         processing:     a Process in Debugger 
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive 
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998, 
with no clients
         nextWormhole:     nil

Wormhole>>greet
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:

     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive 
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream 
connections at port 7...etc...
         processing:     a Process in Debugger 
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive 
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998, 
with no clients
         nextWormhole:     nil

[] in Wormhole(IncomingClient)>>stream:
     Receiver: an inactive instigating Wormhole
     Arguments and temporary variables:
<<error during printing>
     Receiver's instance variables:
         stream:     a binary TCPStream on an inactive 
OutgoingClientTCPSocket which was con...etc...
         transport:     a SocketTransport which opens binary TCPStream 
connections at port 7...etc...
         processing:     a Process in Debugger 
class>>openOn:context:label:contents:fullView...etc...
         pendingOutgoingExchanges:     a Dictionary()
         pendingIncomingExchanges:     an IdentitySet()
         exposedObjects:     an IdentityDictionary(an inactive 
instigating Wormhole->2508962...etc...
         peer:     nil
         peerSet:     a Semaphore()
         instigates:     true
         server:     an active WormholeServer listening on port 9998, 
with no clients
         nextWormhole:     nil

[] in BlockClosure>>newProcess
     Receiver: [closure] in Wormhole(IncomingClient)>>stream:
     Arguments and temporary variables:

     Receiver's instance variables:
         outerContext:     Wormhole(IncomingClient)>>stream:
         startpc:     42
         numArgs:     0


--- The full stack ---
OutgoingClientTCPSocket(TCPSocket)>>next:from:into:startingAt:
OutgoingClientTCPSocket(Peer)>>next:into:startingAt:timeoutAfter:
TCPStream(NetStream)>>next:into:startingAt:timeoutAfter:
TCPStream(NetStream)>>next:timeoutAfter:
TCPStream(NetStream)>>next:
TCPStream(ExternalStream)>>nextWord
Wormhole(MessagingSession)>>nextFrom:
Wormhole(MessagingSession)>>next
Wormhole>>greet
[] in Wormhole(IncomingClient)>>stream:
[] in BlockClosure>>newProcess