<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux/poky.git/bitbake/lib/hashserv/client.py, branch 4.2_M1</title>
<subtitle>Mirror of git.yoctoproject.org/poky</subtitle>
<id>https://git.enea.com/cgit/linux/poky.git/atom?h=4.2_M1</id>
<link rel='self' href='https://git.enea.com/cgit/linux/poky.git/atom?h=4.2_M1'/>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/'/>
<updated>2021-10-11T10:00:06+00:00</updated>
<entry>
<title>bitbake: hashserv: Fix diverging report race condition</title>
<updated>2021-10-11T10:00:06+00:00</updated>
<author>
<name>Joshua Watt</name>
<email>JPEWhacker@gmail.com</email>
</author>
<published>2021-10-07T19:32:00+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=c7c47bb0d2c2263c4668c4269c669b282d6168d9'/>
<id>urn:sha1:c7c47bb0d2c2263c4668c4269c669b282d6168d9</id>
<content type='text'>
Fixes the hashequivalence server to resolve the diverging report race
error. This error occurs when the same task(hash) is run simultaneous on
two different builders, and then the results are reported back but the
hashes diverge (e.g. have different outhashes), and one outhash is
equivalent to a hash and another is not. If taskhash was not originally
in the database, the client will fallback to using the taskhash as the
suggested unihash and the server will see reports come in like:

    taskhash: A
    unihash: A
    outhash: B

    taskhash: C
    unihash: C
    outhash: B

    taskhash: C
    unihash: C
    outhash: D

Note that the second and third reports are the same taskhash, with
diverging outhashes.

Taskhash C should be equivalent to taskhash (and unihash) A because they
share an outhash B, but the server would not do this when tasks were
reported in the order shown.

It became clear while trying to fix this that single large table to
store all reported hashes was going to make these updates difficult
since updating the unihash of all entries would be complex and time
consuming. Instead, it makes more sense to split apart the database into
two tables: One that maps taskhashes to unihashes and one that maps
outhashes to taskhashes. This should hopefully improve the parsing query
times as well since they only care about the taskhashes to unihashes
table, at the cost of more complex INNER JOIN queries on the lesser used
API.

Note this change does delete existing hash equivlance data and starts a
new database table rather than converting existing data.

(Bitbake rev: dff5a17558e2476064e85f35bad1fd65fec23600)

Signed-off-by: Joshua Watt &lt;JPEWhacker@gmail.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: async: Close sync client event loop</title>
<updated>2021-10-11T10:00:06+00:00</updated>
<author>
<name>Joshua Watt</name>
<email>JPEWhacker@gmail.com</email>
</author>
<published>2021-10-07T02:57:06+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=cac6facc9dd125ccf156406f7f3fac84e97f28dc'/>
<id>urn:sha1:cac6facc9dd125ccf156406f7f3fac84e97f28dc</id>
<content type='text'>
Prevents `ResourceWarning: unclosed event loop` warnings when using the
synchronous client and python exits

(Bitbake rev: 8b95972bc04ce52a98c7780184af15a5e95f987b)

Signed-off-by: Joshua Watt &lt;JPEWhacker@gmail.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: hashserver/client.py: drop unused imports</title>
<updated>2021-05-14T06:57:57+00:00</updated>
<author>
<name>Armin Kuster</name>
<email>akuster808@gmail.com</email>
</author>
<published>2021-05-11T12:40:47+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=ed2e3b739a7e0e8daad665fed01342d60674d6b7'/>
<id>urn:sha1:ed2e3b739a7e0e8daad665fed01342d60674d6b7</id>
<content type='text'>
(Bitbake rev: 9dc77266085c605b108641a9d76ac4dbdc064c34)

Signed-off-by: Armin Kuster &lt;akuster808@gmail.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: hashserv: Refactor to use asyncrpc</title>
<updated>2021-04-27T14:12:57+00:00</updated>
<author>
<name>Paul Barker</name>
<email>pbarker@konsulko.com</email>
</author>
<published>2021-04-26T08:16:30+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=421e86e7edadb8c88baf4df68b9fc15671e425de'/>
<id>urn:sha1:421e86e7edadb8c88baf4df68b9fc15671e425de</id>
<content type='text'>
The asyncrpc module can now be used to provide the json &amp; asyncio based
RPC system used by hashserv.

(Bitbake rev: 5afb9586b0a4a23a05efb0e8ff4a97262631ae4a)

Signed-off-by: Paul Barker &lt;pbarker@konsulko.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: hashserv: Use generic ConnectionError</title>
<updated>2021-04-27T14:12:57+00:00</updated>
<author>
<name>Paul Barker</name>
<email>pbarker@konsulko.com</email>
</author>
<published>2021-04-26T08:16:28+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=10236718236e6a12e2e6528abcd920276d181545'/>
<id>urn:sha1:10236718236e6a12e2e6528abcd920276d181545</id>
<content type='text'>
The Python built-in ConnectionError type can be used instead of a custom
HashConnectionError type. This will make code refactoring simpler.

(Bitbake rev: 8a796c3d6d99cfa8ef7aff0ae55bb0f23bbbeae1)

Signed-off-by: Paul Barker &lt;pbarker@konsulko.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: hashserv: Add get-outhash message</title>
<updated>2021-02-10T23:48:16+00:00</updated>
<author>
<name>Paul Barker</name>
<email>pbarker@konsulko.com</email>
</author>
<published>2021-02-05T11:26:10+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=40ecec326effeb1f4dd647849293f18118d4dd21'/>
<id>urn:sha1:40ecec326effeb1f4dd647849293f18118d4dd21</id>
<content type='text'>
The get-outhash message can be sent via the get_outhash client method.
This works in a similar way to the get message but looks up a db entry
by outhash rather than by taskhash. It is intended to be used as a
read-only form of the report message.

As both handle_get_outhash and handle_report use the same query string
we can factor this out.

(Bitbake rev: dc19606ada29a4d8afde4fcecd8ec986b47b867e)

Signed-off-by: Paul Barker &lt;pbarker@konsulko.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: hashserv: client: Fix handling of null responses</title>
<updated>2021-02-06T09:12:00+00:00</updated>
<author>
<name>Paul Barker</name>
<email>pbarker@konsulko.com</email>
</author>
<published>2021-02-05T11:26:05+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=adcd9608a725d99e2e6ca74d4a31e6edb353af0c'/>
<id>urn:sha1:adcd9608a725d99e2e6ca74d4a31e6edb353af0c</id>
<content type='text'>
If the server returns an empty response ("null" in json), this cannot
be iterated to check for the presence of the "chunk-stream" key.

(Bitbake rev: bf75370bcd6d02ed08cd959eec6190196b792515)

Signed-off-by: Paul Barker &lt;pbarker@konsulko.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: hashserv: Fix broken AF_UNIX path length limit</title>
<updated>2020-12-10T13:39:15+00:00</updated>
<author>
<name>Joshua Watt</name>
<email>JPEWhacker@gmail.com</email>
</author>
<published>2020-12-09T21:45:06+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=fe205758a06a7e1cfcca504647da7a82770aeea4'/>
<id>urn:sha1:fe205758a06a7e1cfcca504647da7a82770aeea4</id>
<content type='text'>
Fixes the bug were long paths would break Unix domain socket clients
(for real this time; the previous attempt was missing os.path.basename).

Adds some tests to prevent regressions

(Bitbake rev: 77790e3656048eff5cb1a086c727d86d32773b68)

Signed-off-by: Joshua Watt &lt;JPEWhacker@gmail.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: hashserv: client: Fix AF_UNIX path length limits</title>
<updated>2020-12-09T12:27:25+00:00</updated>
<author>
<name>Joshua Watt</name>
<email>JPEWhacker@gmail.com</email>
</author>
<published>2020-12-02T19:58:10+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=221dc50cde88977907a58aa23a6efd8c289113da'/>
<id>urn:sha1:221dc50cde88977907a58aa23a6efd8c289113da</id>
<content type='text'>
Restores a fix for unix domain socket path length limits when using the
synchronous hash equivalence client that was accidentally removed when
the async client was added.

Unfortunately, it's much more difficult to fix the same problem when
using the async client directly due to the interaction of chdir() and
async code, but this will at least restore the old behavior in the
synchronous case.

(Bitbake rev: 53e85022a8b1c8f407c9418260c59beffb96f0f9)

Signed-off-by: Joshua Watt &lt;JPEWhacker@gmail.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>bitbake: bitbake: hashserve: Add support for readonly upstream</title>
<updated>2020-11-24T15:26:12+00:00</updated>
<author>
<name>Joshua Watt</name>
<email>JPEWhacker@gmail.com</email>
</author>
<published>2020-11-10T14:59:56+00:00</published>
<link rel='alternate' type='text/html' href='https://git.enea.com/cgit/linux/poky.git/commit/?id=96b548a79d87120655da3ac5501b8ad4726cf1a4'/>
<id>urn:sha1:96b548a79d87120655da3ac5501b8ad4726cf1a4</id>
<content type='text'>
Adds support for an upstream server to be specified. The upstream server
will be queried for equivalent hashes whenever a miss is found in the
local server. If the server returns a match, it is merged into the
local database. In order to keep the get stream queries as fast as
possible since they are the critical path when bitbake is preparing the
run queue, missing tasks provided by the server are not immediately
pulled from the upstream server, but instead are put into a queue to be
backfilled by a worker task later.

(Bitbake rev: e6d6c0b39393e9bdf378c1eba141f815e26b724b)

Signed-off-by: Joshua Watt &lt;JPEWhacker@gmail.com&gt;
Signed-off-by: Richard Purdie &lt;richard.purdie@linuxfoundation.org&gt;
</content>
</entry>
</feed>
