Whenever i try to commit to SmalltalkHub i get this Error:
Error: Could not save Boids-MartinWalk.9.mcz: ZnHttpUnsuccessful: 400 Bad
Request

Probably i make something very trivial wrong, as nobody else seems to have
problems?


THERE_BE_DRAGONS_HERE
Error: Could not save Boids-MartinWalk.9.mcz: ZnHttpUnsuccessful: 400 Bad
Request
20 January 2013 3:07:44.564 pm

VM: Mac OS - intel - 1082 - NBCoInterpreter
NativeBoost-CogPlugin-IgorStasenko.15 uuid:
44b6b681-38f1-4a9e-b6ee-8769b499576a Nov 27 2012
NBCogit NativeBoost-CogPlugin-IgorStasenko.15 uuid:
44b6b681-38f1-4a9e-b6ee-8769b499576a Nov 27 2012
https://git.gitorious.org/cogvm/blessed.git Commit:
40ac7e7bdec6fef0e934d2c019b86db996053912 Date: 2012-11-19 18:54:49 +0100 By:
Mariano Martinez Peck <[email protected]> Jenkins build #146

Image: Pharo2.0a [Latest update: #20468]

MCHttpRepository(Object)>>error:
        Receiver: a
MCHttpRepository(http://smalltalkhub.com/mc/MartinWalk/Boids/main)
        Arguments and temporary variables: 
                aString:        'Could not save Boids-MartinWalk.9.mcz: 
ZnHttpUnsuccessful: 400
Bad Re...etc...
        Receiver's instance variables: 
                creationTemplate:       'MCHttpRepository
        location: ''http://smalltalkhub.com/mc/Mar...etc...
                storeDiffs:     nil
                cache:  nil
                allFileNames:   nil
                cacheFileNames:         nil
                location:       
'http://smalltalkhub.com/mc/MartinWalk/Boids/main'
                user:   'MartinWalk'
                password:       'i replaced this for the forum post'
                readerCache:    nil


[:exception | self error: 'Could not save ' , aString , ': ' , exception
printString] in [self httpClient entity: entity;
                
                ifFail: [:exception | self error: 'Could not save ' , aString , 
': ' ,
exception printString];
                
                url: (self urlForFileNamed: aString);
                 put] in MCHttpRepository>>writeStreamForFileNamed:replace:do:
        Receiver: a
MCHttpRepository(http://smalltalkhub.com/mc/MartinWalk/Boids/main)
        Arguments and temporary variables: 
                aString:        'Boids-MartinWalk.9.mcz'
                ignoreBoolean:  false
                aBlock:         [:s | aVersion fileOutOn: s]
                entity:         a ZnStreamingEntity(application/octet-stream 
8341B)
                exception:      ZnHttpUnsuccessful: 400 Bad Request
        Receiver's instance variables: 
                creationTemplate:       'MCHttpRepository
        location: ''http://smalltalkhub.com/mc/Mar...etc...
                storeDiffs:     nil
                cache:  nil
                allFileNames:   nil
                cacheFileNames:         nil
                location:       
'http://smalltalkhub.com/mc/MartinWalk/Boids/main'
                user:   'MartinWalk'
                password:       'i replaced this for the forum post'
                readerCache:    nil


BlockClosure>>cull:
        Receiver: [:exception | self error: 'Could not save ' , aString , ': ' ,
exception printString]
        Arguments and temporary variables: 
                anArg:  ZnHttpUnsuccessful: 400 Bad Request
        Receiver's instance variables: 
                outerContext:   [self httpClient entity: entity;
                
                ifFail: [:exception | self ...etc...
                startpc:        95
                numArgs:        1


[self exceptionHandlerBlock cull: exception] in
MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ZnHttpUnsuccessful: 400 Bad Request
                val:    nil
        Receiver's instance variables: 
                sender:         [[self executeWithRetriesRemaining: self 
numberOfRetries]
                on: Error
        ...etc...
                pc:     17
                stackp:         3
                method:         BlockClosure>>#on:do:
                closureOrNil:   nil
                receiver:       [self executeWithRetriesRemaining: self 
numberOfRetries]


BlockClosure>>ensure:
        Receiver: [self exceptionHandlerBlock cull: exception]
        Arguments and temporary variables: 
                aBlock:         [self exceptionHandlerIsActive: true]
                complete:       nil
                returnValue:    nil
        Receiver's instance variables: 
                outerContext:   MethodContext(ContextPart)>>handleSignal:
                startpc:        99
                numArgs:        0


MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ZnHttpUnsuccessful: 400 Bad Request
                val:    nil
        Receiver's instance variables: 
                sender:         [[self executeWithRetriesRemaining: self 
numberOfRetries]
                on: Error
        ...etc...
                pc:     17
                stackp:         3
                method:         BlockClosure>>#on:do:
                closureOrNil:   nil
                receiver:       [self executeWithRetriesRemaining: self 
numberOfRetries]


MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ZnHttpUnsuccessful: 400 Bad Request
                val:    nil
        Receiver's instance variables: 
                sender:         ZnClient>>executeWithRetriesRemaining:
                pc:     17
                stackp:         3
                method:         BlockClosure>>#on:do:
                closureOrNil:   nil
                receiver:       [self executeWithRedirectsRemaining: self 
maxNumberOfRedirects]


ZnHttpUnsuccessful(Exception)>>signal
        Receiver: ZnHttpUnsuccessful: 400 Bad Request
        Arguments and temporary variables: 

        Receiver's instance variables: 
                messageText:    '400 Bad Request'
                tag:    nil
                signaler:       a ZnClient
                signalContext:  ZnHttpUnsuccessful(Exception)>>signal
                handlerContext:         BlockClosure>>on:do:
                outerContext:   nil
                response:       a ZnResponse(400 Bad Request text/html )


ZnClient>>handleResponse
        Receiver: a ZnClient
        Arguments and temporary variables: 

        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


ZnClient>>executeWithRedirectsRemaining:
        Receiver: a ZnClient
        Arguments and temporary variables: 
                redirectCount:  3
        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[self executeWithRedirectsRemaining: self maxNumberOfRedirects] in
ZnClient>>executeWithRetriesRemaining:
        Receiver: a ZnClient
        Arguments and temporary variables: 
                retryCount:     2
        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


BlockClosure>>on:do:
        Receiver: [self executeWithRedirectsRemaining: self 
maxNumberOfRedirects]
        Arguments and temporary variables: 
                exception:      an ExceptionSet
                handlerAction:  [:exception | retryCount > 0
                ifTrue: [self handleRetry: except...etc...
                handlerActive:  true
        Receiver's instance variables: 
                outerContext:   ZnClient>>executeWithRetriesRemaining:
                startpc:        69
                numArgs:        0


ZnClient>>executeWithRetriesRemaining:
        Receiver: a ZnClient
        Arguments and temporary variables: 
                retryCount:     2
        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[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(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


BlockClosure>>on:do:
        Receiver: [self executeWithRetriesRemaining: self numberOfRetries]
        Arguments and temporary variables: 
                exception:      Error
                handlerAction:  [:exception | self error: 'Could not save ' , 
aString , ':
' , e...etc...
                handlerActive:  false
        Receiver's instance variables: 
                outerContext:   [[self executeWithRetriesRemaining: self 
numberOfRetries]
                on: E...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(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[^ 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(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[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:         nil
                instanceVariables:      nil
                organization:   a ClassOrganizer
                subclasses:     nil
                name:   #ZnConnectionTimeout
                classPool:      nil
                sharedPools:    nil
                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(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


ZnClient>>executeWithTimeout
        Receiver: a ZnClient
        Arguments and temporary variables: 

        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[result := self executeWithTimeout] in ZnClient>>execute
        Receiver: a ZnClient
        Arguments and temporary variables: 
                initialMilliseconds:    121017
                result:         nil
        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[^ block value] in ZnClient>>withProgressDo:
        Receiver: a ZnClient
        Arguments and temporary variables: 
                block:  [result := self executeWithTimeout]
        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[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:         nil
                instanceVariables:      nil
                organization:   a ClassOrganizer
                subclasses:     nil
                name:   #ZnSignalProgress
                classPool:      nil
                sharedPools:    nil
                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(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


ZnClient>>execute
        Receiver: a ZnClient
        Arguments and temporary variables: 
                initialMilliseconds:    121017
                result:         nil
        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


ZnClient>>put
        Receiver: a ZnClient
        Arguments and temporary variables: 

        Receiver's instance variables: 
                request:        a ZnRequest(PUT
/mc/MartinWalk/Boids/main/Boids-MartinWalk.9.mcz)
                response:       a ZnResponse(400 Bad Request text/html )
                connection:     nil
                lastUsed:       nil
                options:        a Dictionary(#enforceAcceptContentType->true
#enforceHttpSuccess->true...etc...
                session:        nil
                log:    a ZnLogSupport


[self httpClient entity: entity;
                
                ifFail: [:exception | self error: 'Could not save ' , aString , 
': ' ,
exception printString];
                
                url: (self urlForFileNamed: aString);
                 put] in MCHttpRepository>>writeStreamForFileNamed:replace:do:
        Receiver: a
MCHttpRepository(http://smalltalkhub.com/mc/MartinWalk/Boids/main)
        Arguments and temporary variables: 
                aString:        'Boids-MartinWalk.9.mcz'
                ignoreBoolean:  false
                aBlock:         [:s | aVersion fileOutOn: s]
                entity:         a ZnStreamingEntity(application/octet-stream 
8341B)
        Receiver's instance variables: 
                creationTemplate:       'MCHttpRepository
        location: ''http://smalltalkhub.com/mc/Mar...etc...
                storeDiffs:     nil
                cache:  nil
                allFileNames:   nil
                cacheFileNames:         nil
                location:       
'http://smalltalkhub.com/mc/MartinWalk/Boids/main'
                user:   'MartinWalk'
                password:       'i replaced this for the forum post'
                readerCache:    nil


[workBlock value] in [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex | 
                        (ex total
                                        ifNil: [true]
                                        ifNotNil: [ex amount == nil])
                                ifFalse: [(nextUpdateTime < Time 
millisecondClockValue
                                                        or: [ex total = ex 
amount])
                                                ifTrue: [bar current: ex amount 
asFloat / ex total asFloat.
                                                        nextUpdateTime := Time 
millisecondClockValue + 100]].
                        ex resume]] in MCHttpRepository>>displayProgress:during:
        Receiver: a
MCHttpRepository(http://smalltalkhub.com/mc/MartinWalk/Boids/main)
        Arguments and temporary variables: 
                label:  'Uploading Boids-MartinWalk.9.mcz'
                workBlock:      [self httpClient entity: entity;
                
                ifFail: [:exception | self err...etc...
                nextUpdateTime:         0
                bar:    a Job
        Receiver's instance variables: 
                creationTemplate:       'MCHttpRepository
        location: ''http://smalltalkhub.com/mc/Mar...etc...
                storeDiffs:     nil
                cache:  nil
                allFileNames:   nil
                cacheFileNames:         nil
                location:       
'http://smalltalkhub.com/mc/MartinWalk/Boids/main'
                user:   'MartinWalk'
                password:       'i replaced this for the forum post'
                readerCache:    nil


BlockClosure>>on:do:
        Receiver: [workBlock value]
        Arguments and temporary variables: 
                exception:      HTTPProgress
                handlerAction:  [:ex | 
(ex total
                        ifNil: [true]
                        ifNotNil: [ex amount == ni...etc...
                handlerActive:  true
        Receiver's instance variables: 
                outerContext:   [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex | 
                        (ex...etc...
                startpc:        108
                numArgs:        0


[:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex | 
                        (ex total
                                        ifNil: [true]
                                        ifNotNil: [ex amount == nil])
                                ifFalse: [(nextUpdateTime < Time 
millisecondClockValue
                                                        or: [ex total = ex 
amount])
                                                ifTrue: [bar current: ex amount 
asFloat / ex total asFloat.
                                                        nextUpdateTime := Time 
millisecondClockValue + 100]].
                        ex resume]] in MCHttpRepository>>displayProgress:during:
        Receiver: a
MCHttpRepository(http://smalltalkhub.com/mc/MartinWalk/Boids/main)
        Arguments and temporary variables: 
                label:  'Uploading Boids-MartinWalk.9.mcz'
                workBlock:      [self httpClient entity: entity;
                
                ifFail: [:exception | self err...etc...
                nextUpdateTime:         0
                bar:    a Job
        Receiver's instance variables: 
                creationTemplate:       'MCHttpRepository
        location: ''http://smalltalkhub.com/mc/Mar...etc...
                storeDiffs:     nil
                cache:  nil
                allFileNames:   nil
                cacheFileNames:         nil
                location:       
'http://smalltalkhub.com/mc/MartinWalk/Boids/main'
                user:   'MartinWalk'
                password:       'i replaced this for the forum post'
                readerCache:    nil


BlockClosure>>cull:
        Receiver: [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex | 
                        (ex total
                                        ifNil: [true]...etc...
        Arguments and temporary variables: 
                anArg:  a Job
        Receiver's instance variables: 
                outerContext:   MCHttpRepository>>displayProgress:during:
                startpc:        103
                numArgs:        1


[result := block cull: self] in [self prepareForRunning.
        [result := block cull: self]
                on: JobNotification
                do: [:notification | notification handle: self]] in Job>>run
        Receiver: a Job
        Arguments and temporary variables: 
                result:         nil
        Receiver's instance variables: 
                block:  [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex | 
                        (ex total
...etc...
                currentValue:   0.0
                min:    0.0
                max:    1.0
                title:  'Uploading Boids-MartinWalk.9.mcz'
                children:       an OrderedCollection()
                isRunning:      true
                parent:         nil
                process:        a Process in nil
                announcer:      nil


BlockClosure>>on:do:
        Receiver: [result := block cull: self]
        Arguments and temporary variables: 
                exception:      JobNotification
                handlerAction:  [:notification | notification handle: self]
                handlerActive:  true
        Receiver's instance variables: 
                outerContext:   [self prepareForRunning.
        [result := block cull: self]
                on: JobN...etc...
                startpc:        57
                numArgs:        0




--
View this message in context: 
http://forum.world.st/Error-when-trying-to-commit-to-SmalltalkHub-tp4664285.html
Sent from the Pharo Smalltalk Users mailing list archive at Nabble.com.

Reply via email to