<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux/poky.git/bitbake/lib/bb/server, branch 1.5_M4</title>
<subtitle>Mirror of git.yoctoproject.org/poky</subtitle>
<id>https://git.enea.com/cgit/linux/poky.git/atom?h=1.5_M4</id>
<link rel='self' href='https://git.enea.com/cgit/linux/poky.git/atom?h=1.5_M4'/>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/'/>
<updated>2013-09-01T14:51:11+00:00</updated>
<entry>
<title>bitbake: server/xmlrpc: stop server on client exit</title>
<updated>2013-09-01T14:51:11+00:00</updated>
<author>
<name>Alexandru DAMIAN</name>
<email>alexandru.damian@intel.com</email>
</author>
<published>2013-08-31T22:46:06+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=6d9e3a19384cbd737fdac729c6c0de5b06f8ec12'/>
<id>urn:sha1:6d9e3a19384cbd737fdac729c6c0de5b06f8ec12</id>
<content type='text'>
If the server only expects a single client to connect (i.e.
no bind parameter set, so there is no way for the
clients to get the server port), stop the server after
the first client exits.

(Bitbake rev: eb6bae56f62082bf147045311154cbae4bca0f4c)

Signed-off-by: Alexandru DAMIAN &lt;alexandru.damian@intel.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: server/process, server/xmlrpc, runqueue: Use select.select() on fds, not time.sleep()</title>
<updated>2013-09-01T14:51:10+00:00</updated>
<author>
<name>Richard Purdie</name>
<email>richard.purdie@linuxfoundation.org</email>
</author>
<published>2013-08-31T22:40:55+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=b306d7d9a4dd5dec0ed1ca91b50569f078ac103e'/>
<id>urn:sha1:b306d7d9a4dd5dec0ed1ca91b50569f078ac103e</id>
<content type='text'>
The existing backend server implementations were inefficient since they
were sleeping for the full length of the timeouts rather than being woken when
there was data ready for them. It was assumed they would wake and perhaps did
when we forked processes directory but that is no longer the case.

This updates both the process and xmlrpc backends to wait using select(). This
does mean we need to pass the file descriptors to wait on from the internals
who know which these file descriptors are but this is a logical improvement.

Tests of a pathaolgical load on the process server of ~420 rapid tasks
executed on a server with BB_NUMBER_THREAD=48  went from a wall clock
measurement of the overall command execution time of 75s to a much more
reasonable 24s.

(Bitbake rev: 9bee497960889d9baa0a4284d79a384b18a8e826)

Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: server/xmlrpc: Increase timeout to 60s</title>
<updated>2013-08-30T16:42:39+00:00</updated>
<author>
<name>Richard Purdie</name>
<email>richard.purdie@linuxfoundation.org</email>
</author>
<published>2013-08-30T16:41:16+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=cb939416b7df27e7410f8084f3622c021e616906'/>
<id>urn:sha1:cb939416b7df27e7410f8084f3622c021e616906</id>
<content type='text'>
This is a better value that the earlier infinite timeout yet still
allows for servers with high loads. It does mean the bitbake process
can hang at exit for the timeout period but that should never happen
and only happened for me in some test cases which wouldn't happen
in normal use.

(Bitbake rev: ab8d926b9bc27c58011e7db9327e031ac76ba34b)

Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: bitbake: Add ui event handlers filtering</title>
<updated>2013-08-26T10:29:46+00:00</updated>
<author>
<name>Richard Purdie</name>
<email>richard.purdie@linuxfoundation.org</email>
</author>
<published>2013-08-23T16:16:50+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=69aab78dd830b0ad570cf9b7bfe2da8e8b793e23'/>
<id>urn:sha1:69aab78dd830b0ad570cf9b7bfe2da8e8b793e23</id>
<content type='text'>
Add functionality to allow UIs to update and change the types of events they
recieve. To do this we need to add a new command and also need to be able
to obtain the current event hander ID. In the case of xmlrpc, this is
straightforward, in the case of the process server we need to save the result
in a multiprocessing.Value() so we can retrive it. An excplit command
was added to the server API to facilitate this.

The same function can also be used to mask or unmask specific log messages,
allowing the UI to optionally differ from the standard set of message
filtering.

Based upon work by Cristiana Voicu &lt;cristiana.voicu@intel.com&gt;

(Bitbake rev: ba5a6c88785d9889d4172ec79937ac2a5555327e)

Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: server/xmlrpc/prserv: Add sane timeout to default xmlrpc server</title>
<updated>2013-08-26T10:29:46+00:00</updated>
<author>
<name>Richard Purdie</name>
<email>richard.purdie@linuxfoundation.org</email>
</author>
<published>2013-08-24T12:03:10+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=bfab986ccd59636d0b0e79309f020e55481b0567'/>
<id>urn:sha1:bfab986ccd59636d0b0e79309f020e55481b0567</id>
<content type='text'>
The standard python socket connect has long timouts which make sense for remote
connections but not local things like the PR Service. This adds a timeout
parameter to the common xmlrpc server creation function and sets it to a more
reasonable 5 seconds.

Making the PR server instantly exit is a good way to test the effect of this
on bitbake.

We can remove the bodged timeout in the PRServer terminate function which
has the side effect of affecting global scope.

(Bitbake rev: 8c01cff94787abbb64fbdf0c16cd63f8f97a7e03)

Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: process: Improve exit handling and hangs</title>
<updated>2013-08-26T10:29:46+00:00</updated>
<author>
<name>Richard Purdie</name>
<email>richard.purdie@linuxfoundation.org</email>
</author>
<published>2013-08-24T11:56:31+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=a03a423c607f53684789ebb5c3c5003568047a14'/>
<id>urn:sha1:a03a423c607f53684789ebb5c3c5003568047a14</id>
<content type='text'>
It turns out we have a number of different ways the process server termination can
hang. If we call cancel_join_thread() on the event queue, it means that it can be left
containing partial data. This means the reading of the event queue in the terminate()
function can hang, the timeout and block parameters to Queue.get() don't make any
difference.

Equally, if we don't call cancel_join_thread(), the join_thread in terminate()
will hang giving a different deadlock.

The best solution I could find is to loop over the process is_alive() after requesting
it stops,  trying to join the thread and if that fails, try and flush the event
queue again.

It wasn't clear what difference a force option should make in this case, we're
gracefully trying to empty queues and shut down regardless of whether its a SIGTERM
so I've simply removed the force option.

(Bitbake rev: c5c8f33ca4b81877a0115887849881001b745bf0)

Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: knotty, xmlrpc: add observer-only mode</title>
<updated>2013-06-17T15:09:10+00:00</updated>
<author>
<name>Alexandru DAMIAN</name>
<email>alexandru.damian@intel.com</email>
</author>
<published>2013-06-17T11:11:51+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=3ea9d647ec35c4d30dcaa5b58e9471b775a4716c'/>
<id>urn:sha1:3ea9d647ec35c4d30dcaa5b58e9471b775a4716c</id>
<content type='text'>
I add an observer only mode for the knotty UI and
the XMLRPC server that will allow the UI to register
a callback with a server in order to receive events.

The observer-UI is able to send read-only commands to the
server, and also is able to register as an event handler.

Read-only commands are the commands that do not change
the state of the server and have been marked as such in
the command module.

The observer can switch to a full client if it calls addClient
at any time, and the server has no other client running.

(Bitbake rev: 4de9ee21f1fa4d04937cc7430fb1fc8b7a8f61e2)

Signed-off-by: Alexandru DAMIAN &lt;alexandru.damian@intel.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: compat/server/utils: Jettison pre python 2.7.3 workarounds</title>
<updated>2013-06-14T16:26:30+00:00</updated>
<author>
<name>Richard Purdie</name>
<email>richard.purdie@linuxfoundation.org</email>
</author>
<published>2013-06-14T16:22:51+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=441c699acbb4b443c705933c1fccee0d906a1262'/>
<id>urn:sha1:441c699acbb4b443c705933c1fccee0d906a1262</id>
<content type='text'>
Now we've moved to require python 2.7.3, we can jettison the compatibility
workarounds/hacks for older python versions.

(Bitbake rev: a51c402304f2080a76720f9b31d6dfdbed393bba)

Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: xmlrpc: removes the event servers controller</title>
<updated>2013-06-14T13:34:59+00:00</updated>
<author>
<name>Alexandru DAMIAN</name>
<email>alexandru.damian@intel.com</email>
</author>
<published>2013-06-07T16:03:06+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=4aebdecdd7ab6147c5357adfe7b99c8ad4182b30'/>
<id>urn:sha1:4aebdecdd7ab6147c5357adfe7b99c8ad4182b30</id>
<content type='text'>
XMLRPC API ran a XMLRPC server at port+2 in order
to provide endpoints to register an event server
in which to dump the events.

This is no longer used, so we remove it.

(Bitbake rev: e171a363913a86e56266f4c9d107110c7f5221e3)

Signed-off-by: Alexandru DAMIAN &lt;alexandru.damian@intel.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: xmlrpc: Allow server to remain memory resident</title>
<updated>2013-06-07T13:13:18+00:00</updated>
<author>
<name>Alexandru DAMIAN</name>
<email>alexandru.damian@intel.com</email>
</author>
<published>2013-05-31T11:06:47+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=f549cdd712939990531562b308e2dcea88deba40'/>
<id>urn:sha1:f549cdd712939990531562b308e2dcea88deba40</id>
<content type='text'>
This patch enables the XMLRPC server to remain
resident in memory after a task is run, and to accept
a new controlling client. To check the server after
task completion, do

lsof bitbake.lock

in the build directory. Kill the server with kill.

(Bitbake rev: e823e1f0675ff3794eb39ef0b4df2d7a220f4013)

Signed-off-by: Alexandru DAMIAN &lt;alexandru.damian@intel.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
</feed>
