Add eslint_d maker

This PR adds the eslint_d JavaScript maker. It wraps eslint and avoids delays by preloading the required modules (see here). Its usage is identical to eslint.

thanks for the contribution!


GraphQL schema exposes customer data

Nothing critical seems to be exposed but perhaps this should be locked down. There are lots of use cases where you don't want to leak the emails of purchasers.

@Benjamin-Lee  Thank you for catching this 🚀
Had a few rogue skipAuth directives from early development days to make testing easier :)


module 'pychromecast' has no attribute 'get_chromecasts'

Hello,
I just tried the very first example :
#!/usr/bin/env python3
import pychromecast
chromecasts = pychromecast.get_chromecasts()
[cc.device.friendly_name for cc in chromecasts]

I got the followinf error :
Traceback (most recent call last):
  File "./testPychromecast.py", line 5, in <module>
    chromecasts = pychromecast.get_chromecasts()
AttributeError: module 'pychromecast' has no attribute 'get_chromecasts'

I installed Python 3.7 and I ran the following commands :

python3 -m pip install -r requirements.txt
python3 setup.py build
python3 ./setup.py install

But nothing changed... Can somebody helps me please ? I'm in the python env since 1 month.
Thank you

Hey, just a quick question. Are you running your script in the same directory where you checked out the pychromecast repo? If so, python will try to look in that directory instead of the module and complain. Rename the repo a la: mv pychromecast pychromecast.repo (or whatever) and then python3 yourscript.py


Considering implementing UX improvements

https://docs.google.com/a/google.com/document/d/15dXu1982AErNTPsqimZcI_urWNDZN0Hjypc44F8aFCs/edit?usp=sharing

Relevant stuff at the bottom of the document.

using #1477 to track this


bug in fr_CA.coffee prevents meteor 1.5 startup

Hello. My application cannot startup with Meteor 1.5, due to error: "ReferenceError: fr is not defined
W20170704-19:22:12.926(-4)? (STDERR)     at packages/softwarerero_accounts-t9n.js:1907:15'
I locate the fr variable bug in fr_CA.coffee:
var fr_CA = {};
T9n.map "fr", fr

it should be
var fr_CA = {};
T9n.map "fr_CA", fr_CA

Just pushed 1.3.11 with a hotfix.

thank you for your quick support.

Is this bug still open?

Closing this as it should be fixed

Sorry for late reply. I confirm this has been fixed


S3Store.stat always returns a Url even if the key doesn't exist in the s3 bucket

https://github.com/fs2-blobstore/fs2-blobstore/blob/34eeb7ad34daadd421eee7e25ccb15c75f78e66c/s3/src/main/scala/blobstore/s3/S3Store.scala#L434
Documentation on Store.stat is a little lacking, but my understanding is that it should return a stream with a single url if the object exists in the store, and an empty stream if the object does not exist, so that it's possible to determine if an object is in the store before trying to, say, get it.
The implementation of S3Store.stat always returns a stream containing a single url, even if the key does not exist in s3.

@DougC thank you for raising the issue, v0.8.7 and v0.9.7 have been released.

That's brilliant! Thanks very much for your work on this library.


⚠ Bofrost.fr has degraded performance

In 7758519, Bofrost.fr (https://www.bofrost.fr) experienced degraded performance:

HTTP code: 200
Response time: 837 ms

Resolved: Bofrost.fr performance has improved in d040fb6 after 7 minutes.


Improve server-side api - routes/schema

The following are a few very rough ideas on how to improve the server-side api, especially for data validation.

The server side api is currently quite hard to use and very low-level.
These are a few ideas on how this could be improved:
Routes
We might add a feature to explicitly define routes/paths/nodes that are updatable, basically a schema. Currently, clients can set any kind of value. We could introduce a strict mode that prevents writing data outside of defined routes.
This would allow us to validate the requests, add callbacks to updates and add authorization logic for example.
I don't know yet how such an api might look like. A few ideas:
const users = route('users').route(':id').writable<{name: string}>(data => validate(data));
const stats = route('stats').route('visitors').readable<number>();

server.routes(users, stats);

// ---- or

// zod schema
const userSchema = z.object({
	name: z.string().min(1)
});

const db = server.schema({
	users: {
		':id': ({data}) => userSchema.parse(data);
	},
	stats: {
		visitors: () => {}, // read-only
	}
}).listen();

db.on('connection', () => {
	db.stats.visitors.set(current => current+1);
});

export type Schema = inferSchema<typeof db>; // this can now be used in the client

// -- client

const client = SocketDBClient<Schema>();

client.get('users').get('1').get('name').set('James');
client.get('stats').get('visitors').set(10); // does not do anything

Server functions
In addition, or even instead of the above, we could add server-side functions that can be called from the client side:
db.path('stats').callbacks({
	incrementVisitors: callback(({path}) => {
		path.visitors.set(current => current + 1);
	}),
	setVisitors: callback(z.number(), (count, {path, session}) => {
		if (session.user.role === 'admin') {
			path.visitors.set(count);
		}
	}),
});

// --- client
client.get('stats').call('incrementVisitors');

Or we could combine both approaches:
const users = schema({
	value: collection().schema({
		value: writable(z.object({
			name: z.string()
		}))
	}),
	signUp: callback(z.object({
		name: z.string(),
	}), (input, {path}) => {
		path.set({
			name: input.name,
		})
	}),
});

const stats = schema({
	value: schema({
		visitors: schema({
			value: readonly<number>(),
			increment: callback(({path}) => {
				path.set(current => current + 1)
			}),
		})
	}),
});

More sketches:
const router = graph({
	users: collection().graph({
		name: value(z.string()),
	}),
	signUp: callback(z.object({
		name: z.string(),
	}), (input, {path}) => {
		path.parent.get('users').push({
			name: input.name,
		})
	}),
	stats: graph({
		visitors: value(z.number()),
		incrementVisitors: callback(({ path }) => {
			path.parent.get('visitors').set(current => current + 1);
		})
	})
});

const schema = tree({
  users: collection({
    name: leaf(z.string())
  }),
  stats: {
    visitors: leaf(z.number())
  }
});

A different concept, heavily inspired by tRPC:
Server example
const playerRoute = route({
	create: procedure
		.arguments(z.object({
			name: z.string()
		}))
		.mutate(({args, db}) => {
			db.get('players').get(nanoid()).set(args);
		}),
	move: procedure
		.arguments(z.string())
		// multiple payloads will be batched
		.payload(z.object({
			x: z.number(),
			y: z.number()
		}))
		// call with same arguments will only be sent again when local cache changes, at the given path
		.affects(({args}) => [`/players/${args}/x`, `/players/${args}/y`])
		.mutate(({args, payload, db}) => {
			db.get('players').get(args).set(payload);
		}),
	getWithinRange: procedure
		.arguments(z.object({
			x: z.number(),
			y: z.number(),
			width: z.number(),
			height: z.number(),
		}))
		// calls to "db" are automatically tracked to create a dependencies array
		// whenever any of the dependencies change, the query is re-run
		.query(({args, db}) => {
			return db.get('players').filter(user => isWithinBoundingBox(args, user));
		}),
	getTeamsForPlayer: procedure
		.arguments(z.string())
		.query(({args, db}) => {
			const player = db.get('players').get(args);
			return db.get('teams').filter(team => team.id === player.teamId);
		}),
	// ....
});

const router = createRouter({
	player: userRoute
});

This can then be used like:
const client = createClient(router);

client.player.create({name: 'Michael'});
client.player.create({name: 'Michael'});
// sends:
// [
// 	["player/create", {name: 'Michael'}],
// 	["player/create", {name: 'Michael'}]
// ]

client.player.move('1', {x: 0, y: 1});
client.player.move('1', {x: 2, y: 1});
client.player.move('1', {x: 2, y: 1});
client.player.move('2', {x: 5, y: 10});
// sends:
// [
// 	["/player/move", '1', {x: 2, y: 1}],
// 	["/player/move", '2', {x: 5, y: 10}],
// ]

client.player.getTeamsForPlayer('1').on(teams => console.log(teams));
// => []
client.player.addToTeam({id: '1', teamId: '2'});
// => [{id: 2}]

A few notes on how this works:
There are a) mutations and b) queries.
Mutations
Mutate values on the server.

arguments(): define the input to the function, the given schema validates the input from the client
payload():  the same as arguments(), but this will be batched on consecutive calls
affects(): allows you to define paths to check for changes before calling the function with the same arguments

this will skip multiple calls with the same arguments / payload when the data for the given paths has not changed
for example: the player sends a position update 60x per second. But we do not need to send an update if the position has not changed. We cannot run the mutation on the client, but we can skip consecutive calls with the same arguments/payload. As long as we know that the data (defined by affects()) has not been modified by another client.

mutate(): runs the mutation

Queries
In addition to the above:

query(): queries the database and returns the result.

Calls to the database (e.g. db.get('players') will be tracked. Anytime those dependencies change, the query will re-run and notify the client.

I think this solves multiple issues:

allows defining strict routes on the server
includes validation out of the box
provides a flexible way to write server-side logic (server-side functions, filter/queries, events, etc.)
adds a powerful api to create reactive queries
fixes the problem of creating ids on the client side (e.g. adding things to lists)
allows for easy authorization logic
completely gets rid of clumsy update interceptors (e.g. intercept('server:update'))
still allows to batch updates: multiple calls with the same arguments but different payloads will be batched into a single call with combined payloads
only sends updates when needed (by defining affects)

Shortcomings

The api is a bit confusing:

I think the difference between arguments() and payload() might not be very clear.
Some functions, like affects and payload do not have an effect on queries. So maybe the api should be a bit different and not allow them to be chained.
The user has to define affected paths to make the mutation more efficient. This might be error-prone and a bit verbose.

Addressed by #79


Remove the top-level systemd directory

Alongside the new option to create Debian packages from our build scaffolding we mvoed the systemd unit file templates to vast/services/systemd. The old top-level systemd directory remained as the contained configuration file was used by the top-level Dockerfile. This commit cleans that up by removing the directory and switching the Dockerfile to use environment variables rather than a copied configuration file, which was not an option at the time the Dockerfile was created.

:memo: Reviewer Checklist
Review this pull request by ensuring the following items:

[ ] All user-facing changes have changelog entries
[ ] User-facing changes are reflected on vast.io

Is this merge-able or would it interfere with #2513 ?

Is this merge-able or would it interfere with #2513 ?

This is stacked on top of #2513, and I think it'd be easier to first resolve the remaining feedback items in there before merging this, so we don't interfere with @tobim.

If another PR is stacked on top of your PR, it's usually better to merge master back instead of rebasing on top of master, because that won't cause this issue. I'll just have to rebase this manually now to resolve the issue (which is no big deal).


add a RenderWidget

cc @ellisonbg

cc @jasongrout

Have some feedback before it is merged
Sent from my iPhone

On Jul 11, 2017, at 4:57 PM, Steven Silvester<EMAIL_ADDRESS>wrote:
@blink1073 approved this pull request.
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub, or mute the thread.

:patientlywaiting:


Android: Built in browser

See this forum thread: https://forum.newsblur.com/t/android-built-in-browser-because-twitter-videos-doesnt-play-on-android/8177
On iOS we give users an option of using an in-app browser or use the full Safari browser with an app switch. Android should have a similar preference.

This is great! Can we add a way to immediately come back to the story? I found that using the in app browser I would go in a few links and then have to completely unwind them. Also, swiping back from the edge wasn't working, although that may be an iOS only feature.

Also, the in app browser should be used when tapping on the story title while in the story detail view (and not just the links in the story content).

Swiping from the edge should close the page, similar to a back button action. Are you seeing a different behavior?
Also now it will close without needing to unwind links

When will this be released to the production app? I looked through the commits but didnt see anything about a release tag or schedule.

I just released it today as part of v10.1b5 on the beta channel. Switch to beta and let me know how it's working.

@samuelclay it's working great so far! There are just 3 areas that could be improved:

I think the back button should unwind links instead of going directly back to story. But, that's personal preference.
User should be able to copy the URL of the currently viewed page (e.g. if they navigate several links deep past the story and want to extract the URL for archiving or sharing)
User should be able to tap-and-hold to copy inline links.


kubeadmcontrolplane do not scale up

/kind bug
What steps did you take and what happened:
Do the Quick-Start
The kubeadmcontrolplane do not scale up to 3 replicas with the following warning:
Status:
  Conditions:
    Last Transition Time:  2023-08-02T07:36:41Z
    Message:               Scaling up control plane to 3 replicas (actual 1)
    Reason:                ScalingUp
    Severity:              Warning
    Status:                False
    Type:                  Ready
    Last Transition Time:  2023-08-02T07:39:35Z
    Status:                True
    Type:                  Available
    Last Transition Time:  2023-08-02T07:36:21Z
    Status:                True
    Type:                  CertificatesAvailable
    Last Transition Time:  2023-08-02T07:36:51Z
    Status:                True
    Type:                  MachinesReady
    Last Transition Time:  2023-08-02T07:36:41Z
    Message:               Scaling up control plane to 3 replicas (actual 1)
    Reason:                ScalingUp
    Severity:              Warning
    Status:                False
    Type:                  Resized
  Initialized:             true
  Observed Generation:     1
  Ready:                   true
  Ready Replicas:          1
  Replicas:                1
  Selector:                cluster.x-k8s.io/cluster-name=cappx-test,cluster.x-k8s.io/control-plane
  Unavailable Replicas:    0
  Updated Replicas:        1
Events:
  Type     Reason                 Age                  From
                    Message
  ----     ------                 ----                 ----
                    -------
  Warning  ControlPlaneUnhealthy  44s (x143 over 73m)  kubeadm-control-plane-controller  Waiting for control plane to pass preflight checks to continue reconciliation: Machine cappx-test-qvsbk does not have a corresponding Node yet (Machine.status.nodeRef not set)

What did you expect to happen:
The kubeadmcontrolplane scales up to 3 without the error
Anything else you would like to add:
[Miscellaneous information that will assist in solving the issue.]
Environment:

Cluster-api-provider-proxmox version: v0.3.3
Proxmox VE version: 8.0.3
Kubernetes version: (use kubectl version): v1.27.3
OS (e.g. from /etc/os-release): default(ubuntu)

It's not a bug or something but expected behavior.
Because cappx does not initialize the nodes (does not add providerID to nodes), Machines never get Machine.status.nodeRef.
Node initialization can be done by CCM so once you deploy CNI and CCM (this is applied by clusterresourceset if you are using QuickStart template) to workload cluster, the Machines get nodeRef and controlplane will scale up.

Thank you for your fast reply!


keep tabs in sync via broadcast channel

https://user-images.githubusercontent.com/1009003/203170976-285bfead-72c1-4295-b068-62eadf6da251.mov

@sgbeal -- you might be interested in this.
The video in the PR description above is using wa-sqlite in two tabs pointed to the same DB. A broadcast channel tells the tab to re-query when and update is made in another tab. Things work seamlessly.
The video below is using the official SQLite wasm build.
https://user-images.githubusercontent.com/1009003/203171890-65bd8eb4-1c38-4105-b021-cdf9e6f1262b.mov
The official build fails pretty much immediately due to a lock still being held by the write in the other tab.

Follw-up: i've looked back into wa-sqlite and see that one of the reasons that API can offer better concurrency is that, for example, if a read request comes in but the VFS has no lock for that file, it's reading that file without having a lock:
https://github.com/rhashimoto/wa-sqlite/blob/master/src/examples/OriginPrivateFileSystemVFS.js
  xRead(fileId, pData, iOffset) {
...
      if (fileEntry.accessHandle) {
        nBytesRead = fileEntry.accessHandle.read(pData.value, { at: iOffset });
      } else {
        // Not using an access handle is slower but allows multiple readers.
        const file = await fileEntry.fileHandle.getFile()
        const blob = file.slice(iOffset, iOffset + pData.value.byteLength);
        const buffer = await blob.arrayBuffer();
        pData.value.set(new Int8Array(buffer));
        nBytesRead = Math.min(pData.value.byteLength, blob.size);
      }
...
  }

That is not, IMO, a solid solution. It is possible for a concurrent writer to modify that data while it's being read that way. The MDN docs say:

If the file on disk changes or is removed after this method  [FileSystemFileHandle.getFile()] is called, the returned File object will likely be no longer readable.

The operative work being "likely," i.e. implicitly unknown/undefined. That is definitely not an approach i'm comfortable taking.
Looking closely at the file-related APIs, File.size returns the size of a file, just like OPFS's FileSystemSyncAccessHandle.getSize()^1, but the latter requires a write lock. The fact that there's a different API for that ostensibly same method strongly implies that there's a low-level functional difference between how File and FileSystemSyncAccessHandle model a file's size. There's nothing in the API which prohibits a File object from being modeled as an in-memory blob (File derives from Blob, which implies that that's the case, but no docs i've found come out and say it is or isn't), as opposed to an on-storage object, the implication of which is that the approach of the xRead method above may well read the whole file into memory just to slice out a single db page. Even if that's not the case (which we don't know because the JS API docs are not detailed enough to tell us), switching between two different models of the filesystem, as wa-sqlite is doing, feels fragile to me.
i've looked into Web Locks as an alternative locking approach but they appear to buy us nothing and add yet another layer of locking. Since we require an OPFS lock (i.e. sync access handle) to do any writing or size-fetching, having a Web Lock to also block access on seems like it would add complexity and a performance hit for no functional benefit. i'm open to being convinced otherwise, though.
The OPFS folks are currently looking into a locking API more akin to Posix locks. If and when they introduce that, we'll use it to improve the concurrency situation, but i'm not currently convinced that following wa-sqlite's lead on bypassing OPFS's API for read operations is a viable solution for us.

Follw-up: i've looked back into wa-sqlite and see that one of the reasons that API can offer better concurrency is that, for example, if a read request comes in but the VFS has no lock for that file, it's reading that file without having a lock: [...]

Wow. So much disinformation. And let's just assume wa-sqlite is "not IMO a solid solution" and "fragile" upon finding something that doesn't make sense to you, instead of asking how that actually works or alerting me directly to what would be a major bug.

i'm open to being convinced otherwise, though.

I really wonder, TBH.

Also @sgbeal I appreciate the thorough answer with references.
My current focus is on my extension to SQLite but, once that wraps up, I'll have some time to help dig into this specific issue.

@rhashimoto my sincere apologies if my post was interpreted as an attack or FUD. i am always open to being taught the error of my ways. Can you please, for example, explain how the above xRead() is legal without a sync access handle in a multi-tab/multi-worker environment? My reading of both the code and the MDN docs is that it is that a writer may modify that file while the read is going on, leading to, insofar as i can determine, undefined results. If that's not the case, i'd love to understand why so that i can consider an equivalent solution our project's xRead().

And for what it's worth, @rhashimoto, you are undeniably my senior when it comes to the sqlite3 VFS and cutting-edge JS. i'm not here to try to teach you anything. On the contrary, i study your code to learn.

@sgbeal The words are nice but they don't match the behavior. This is not the only case where you use a hot take based on a shallow (at best) investigation to denigrate another project. Consider this on the SQLite website:

James Long's aptly-named absurd-sql demonstrates persistent browser-side sqlite3 by storing the databases in IndexedDB storage. We experimented with that approach but it's... well, absurd 😉. It's too slow for anything beyond trivial databases and it's easy to get a database in an inconsistent state by visiting the page from two tabs.

I think you admitted that your experiment wasn't anything close to the absurd-sql approach. However, apparently the official SQLite position remains that the absurd-sql approach is too slow for real databases (!) and vulnerable to multi-tab corruption? Granted, as it turns out there are reports of absurd-sql corruption with multiple tabs, but (1) I think this is coincidental to your findings (as you don't recall implementing any explicit locking), and (2) a bug that can be fixed doesn't invalidate the entire approach. Choosing not to use IndexedDB is fine; tagging absurd-sql on this "evidence" in order to justify that decision is not.
As an apology for the rant in your space, @tantaman, I will answer the question in a separate message so you can edit/hide/delete this one as you see fit.

@rhashimoto you may or may not care to hear that i've toned down the absurd-sql attribution you referred to. My unashamed personal dislike of IndexedDB does not reflect an "official stance" of the sqlite project and i'll make a point of avoiding strongly-worded/contentious personal takes in the documentation. i look forward to being corrected on the "unlocked xRead()" point.

First, let's get a few things straight. I'm not an expert in Javascript or SQLite. I think it's quite likely that I've written more SQLite VFSs for the browser (8+ and counting) than anyone else, but a big part of the reason for that is some of the early ones were so terrible. The current ones may be still be terrible in all new and different ways. I have experience with this (i.e. bugs and mistakes) but anyone should feel free to go a different way. In fact, enabling people to easily try different things is the primary reason wa-sqlite exists; it's not really intended to support production apps as-is, other than my own.
Second, @tantaman are you really using the wa-sqlite OriginPrivateFileSystemVFS in your app? If you are, I probably wouldn't - I consider IDBBatchAtomicVFS to be easier to integrate, higher performance, and more mature, basically everything that matters to an app writer. If you aren't, then we need to keep in mind that it's not a real apples-to-apples comparison with the Official SQLite WASM (OSW from now on) for purposes of analyzing the OPFS implementation. Right now it seems like you're saying that wa-sqlite is working fine with OPFS and OSW is not; I want to know whether that is actually the case before I make any ridiculous claims.

If you aren't, then we need to keep in mind that it's not a real apples-to-apples comparison with the Official SQLite WASM (OSW from now on) for purposes of analyzing the OPFS implementation.

Absolutely. The OPFS-specific details are of course similar but the synchronous-interface-behind-an-async-impl bit is apples and oranges.

Right now it seems like you're saying that wa-sqlite is working fine with OPFS and OSW is not; I want to know whether that is actually the case before I make any ridiculous claims.

At the time this post was started, the claim that OSW was utterly failing in terms of OPFS concurrency was absolutely correct! Even getting two connections going was unreliable. We've since created a multi-worker test app which has allowed us to make some headway in improving that:
https://wasm-testing.sqlite.org/tests/opfs/concurrency/
(no guarantees on the stability of that URL and it will only work with an OPFS-capable browser)
As it currently stands, our extremely basic tests are reliably hosting up to 3 handles to the same db (one per worker), each one performing a tiny bit of work every 750-1000ms, but they get flaky quickly as more workers are added. By making one particular concurrency-over-speed tweak we can about double that, but that's a measure of last resort because it cuts the runtime speed of high-I/O benchmarks by about 4x. Our standard benchmarking app is a wasmified build of sqlite's own "speedtest1" app:
https://wasm-testing.sqlite.org/speedtest1-worker.html?vfs=opfs&size=25
(same link disclaimer as above)
How that compares to wa-sqlite, i cannot say and have no basis for speculation. It would surprise me if wa-sqlite's "concurrency cap" is not significantly higher.
i'm still studying your Web Locks impl to try to get my head around it well enough to figure out if a similar approach will help us (as it demonstrably has wa-sqlite), but my brain still struggles with Promise-heavy APIs for whatever reason.

I looked through the source tree and I don't see any references to OriginPrivateFileSystemVFS, so I'm going to assume it's IDBBatchAtomicVFS running in the video (I also see @tantaman making quasi-legal arguments to justify violating the spirit of the GPL so maybe we should discuss that sometime). Both OriginPrivateFileSystemVFS and IDBBatchAtomicVFS use Web Locks so that part is the same, but we can't rule out that OriginPrivateFileSystemVFS might not behave as well, e.g. there might be some issues with the browser implementation of OPFS which would show up with both libraries. As I mentioned before, there's no good reason for app writers to use OriginPrivateFileSystemVFS, so I don't think it's been exercised well (or maybe even at all) outside of my own limited tests. It's something to keep in mind.

If the weblock is held while reading (thus preventing a write) then it sounds like this wouldn't be problematic.

Yes, this is the essential idea. Unless someone explicitly disables locking, SQLite will issue xLock/xUnlock calls as needed to protect the database against inconsistent reads and writes.

if a read request comes in but the VFS has no lock for that file, it's reading that file without having a lock: [...]

That is not, IMO, a solid solution. It is possible for a concurrent writer to modify that data while it's being read that way.

This is not the case. SQLite allows two kinds of files to be opened by multiple connections at the same time, main database files and main journal files, and they both are protected by locking the main database file. So before we start talking about OPFS at all, SQLite will not call xRead, xWrite, xFileSize, xTruncate, etc. unless it is safe to do so, i.e. the file is used by a single-connection (typically a uniquely named temporary file) or within the scope of a lock, a shared lock for reading or an exclusive lock for writing.

i've looked into Web Locks as an alternative locking approach but they appear to buy us nothing and add yet another layer of locking. Since we require an OPFS lock (i.e. sync access handle) to do any writing or size-fetching, having a Web Lock to also block access on seems like it would add complexity and a performance hit for no functional benefit.

It is true that Web Locks does add another layer of locking on top of OPFS. It is not true that there is no functional or performance benefit. Web Locks is a superior API for locking because it queues your locking request and waits for the lock to become available. In contrast, OPFS either gives you the lock or throws an exception (within the returned Promise). This makes it a lot more difficult to maintain performance and avoid starvation.
Let's look at what happens with OSW when we try to start a transaction when another connection has the lock. Here's the handle acquisition code, which doubles as the locking code:
https://github.com/sqlite/sqlite/blob/902ea8392536b729c4c4553613dae9f65a4c1bf3/ext/wasm/api/sqlite3-opfs-async-proxy.js#L253-L274
At t=0 we call OPFS await createSyncAccessHandle() (line 260). When another connection has an access handle, this throws and we sleep until a retry signal or timeout on line 272. Perhaps I'm missing it, but I don't see anything that actually issues retry - if I'm not wrong about that, we'll try again at t=600, t=1500, and t=2700 until we succeed or give up. If the other connection happens to release its handle right before we wake up then that's great but that would be really lucky. It is much more likely that the other connection will release the access handle at some time other than right at the end of our sleep.
What if the other connection releases the handle in the middle of our sleep, say at t=300 for purposes of discussion? Two things can happen. The first is that some other connection, perhaps the same connection that just released the handle (fairly likely), jumps in and grabs the handle again, which is unfair if we had made our request request. The second is we get the handle when we try again at t=600, which means the database has been sitting idle for 300 ms while we were waiting to use it. Neither of these things are good - one contributes to starvation and the other one saps performance.
I think that you could make this work if that retry is in fact used; I just didn't see it being set or reset anywhere. If it is being used you will get spurious wake-ups if you have more than two-way contention (my understanding is Atomics.notify wakes up everyone), not horrible but not preferable. Actually, I'm not certain that it isn't always 0, in which case it would be spinning instead of sleeping, also not great. Perhaps @sgbeal can clarify.
If you use Web Locks to implement xLock/xUnlock then the request waits on the lock - there is no idle time, no spinning, no spurious wake-ups, and no starvation. Whatever connection has the lock has the right to xRead, xWrite, or whatever (depending on the type of lock). Getting an access handle should always succeed, except for actual errors, at least in the default journal_mode (we'll talk about other modes in a bit) so the cost of that extra layer of locking should be negligible (because acquiring a lock that is available is the path that implementations optimize) and you're not using exceptions to handle normal events. It's also a lot easier to work with and reason about Web Locks than OPFS locks, especially because you can dump the state of all your locks (with LockManager.query) when debugging concurrency.
On to the specifics of OriginPrivateFileSystemVFS. It implements xLock/xUnlock using Web Locks (via a helper class, WebLocksExclusive) as described. There is a drop-in replacement helper class, WebLocksShared, which allows shared read locks. In addition, xLock acquires an OPFS access handle when it gets an exclusive lock and xUnlock releases the handle when it loses the lock (bug here, should be !== VFS.SQLITE_LOCK_EXCLUSIVE instead). This manages the writable access handle for main databases. Reads of main databases are done via the File interface if no access handle exists (i.e. if the database is not locked for write), which is slower but allows multiple readers (if WebLocksShared is used).

switching between two different models of the filesystem, as wa-sqlite is doing, feels fragile to me.

This is not a problem. The locking guarantees that only one model is being used at a time, and if you look carefully a new File object is created when needed. The use of File does reduces performance on a single connection. That was an implementation decision because as a proof of concept experiment, enabling concurrent read transactions was more interesting to me than optimizing for single connection speed. Ideally a production VFS could have the best of both worlds by switching the behavior based on the locking_mode pragma (pragma settings are delivered via xFileControl).
For files that are not a main database, the OPFS access handle is acquired in xOpen and released in xClose. There is a bug in OriginPrivateFileSystemVFS here: this works for main database journals with the default journal_mode, DELETE, but not with TRUNCATE or PERSIST (which may be desirable for better performance). When the journal_mode is TRUNCATE or PERSIST, multiple connections can open the journal file so this will result in an SQL_IOERR for all but the first connection to open it.  How should this bug be fixed?
OSW handles this by releasing the handles after the file system is idle for some period of time. This works, but I don't like it. When you switch to a waiting connection, the database will be idle for the timeout duration so that saps performance. And how do you tune it? My 8-year-old laptop can execute a transaction in ~20 ms - who's to say it's reasonable to idle for 150 ms? It's not obvious to me that there is a reasonable one-size-fits-all timeout. It might depend on CPU speed, disk speed, browser, the queries, etc. I think a better solution is out there.
My preferred fix would be to acquire the handle for a main database journal in xOpen on the journal file if the main database is locked and in xLock on the database file, and to release the handle in xUnlock on the database file or xClose on the journal file. @sgbeal considers this be an ugly hack. I don't because the journal naming scheme is documented and the xOpen flags identify the type of file (so you can't be fooled by a database file named "foo-journal", for example). Perhaps someone could ask a SQLite architect for an opinion. It might also be possible to get the association between database and journal names in the C VFS and pass that to Javascript; I believe both names are available in the database pager.
Another alternative fix would be to use BroadcastChannel to signal a VFS to release a journal access handle. BroadcastChannel is another of those APIs that are new but supported everywhere OPFS is. A connection that needs the access handle can request other connections with the journal file open to release the handle if they have it. I would guard the access handle possession with a Web Lock, not so much because it needs to be locked but because it's an efficient way to wait on the access handle availability.
Either of these fixes should keep the database from being idle before acquiring a journal access handle in PERSIST or TRUNCATE mode. I expect the overhead to be small, much less than the timeout, and as a bonus with a single connection the journal access handle would never need to be reacquired.

I also see @tantaman making quasi-legal arguments to justify circumventing the spirit of the GPL

Yeah, I agree it is against the spirit but maybe or maybe not the letter. In either case, I'm not the best person to weigh in on it. I can remove that text and indicate that that package is GPL (already done here -- https://github.com/vlcn-io/cr-sqlite/blob/main/js/wasm-esm/wa-crsqlite/README.md). Also, given strut does make direct use of wa-sqlite (and not one of the other db connectors) I can re-license that project to GPL.

Web Locks is a superior API for locking because it queues your locking request and waits for the lock to become available

Given web locks is async would using them would require sqlite to be rebuilt with asyncify?

Another alternative fix would be to use BroadcastChannel to signal a VFS to release a journal access handle. BroadcastChannel is another of those APIs that are new but supported everywhere OPFS is

Interesting idea. I'll have to study the VFS code a bit more.

I don't because the journal naming scheme is documented and the xOpen flags identify the type of file

FWIW, I believe fly.io makes extensive use of knowing the names sqlite uses for WAL (and potentially Journal if you're in that mode) files for their litestream project.

Given web locks is async would using them would require sqlite to be rebuilt with asyncify?

No. OSW already uses asynchronous APIs, including OPFS because only a small subset of its methods are synchronous. OSW (like absurd-sql) keeps the WASM synchronous by using SharedArrayBuffer to bridge that WASM Worker to another Worker where asynchronous calls (like OPFS or Web Locks or anything really) can be made.
The OPFS spec has recently been changed to make more of the OPFS API methods synchronous - it used to be just read and write but soon will include file size, truncate, etc. However, it looks like opening an OPFS access handle will remain asynchronous so the need for either SharedArrayBuffer or Asyncify is not going away in the near future. WASM Promise integration seems to be the most, um, promising.

Wow, that's a lot to digest. A few notes before i have to get back to packing:

Web Locks: we (OSW) didn't bother to look into Web Locks initially because they're not portable yet. It wasn't until a week or two ago that an anonymous forum poster pointed out that they're everywhere OPFS is that Web Locks began to make sense. The current wait/retry approach is most definitely not ideal - it was a quick and easy solution which fit within the overall infrastructure and is not a solution we're emotionally tied to.

The sqlite3_vfs locking behavior you describe is very helpful info and i'll re-do the xRead() to do the "slow unlocked read" when called without an explicit xLock(). If that doesn't absolutely tank performance (and i don't think that it will), that would be a big improvement right off the bat. IIRC most of the lock-related failures in my testing are either in xRead or xOpen.

There is a bug in OriginPrivateFileSystemVFS here: this works for main database journals with the default journal_mode, DELETE, but not with TRUNCATE or PERSIST (which may be desirable for better performance). When the journal_mode is TRUNCATE or PERSIST, multiple connections can open the journal file so this will result in an SQL_IOERR for all but the first connection to open it. How should this bug be fixed?

Aha! That explains OWS's immediate contention when attempting that same trick. i don't have an answer to that final question but just FYI: our experimentation shows TRUNCATE to be the fastest mode on OPFS, so we try to default OPFS connections to that mode (but that really depends on how the client opens the db). In our I/O-heavy benchmarking (the speedtest1 app), the speed difference between TRUNCATE and DELETE is visible to the human eye, without bothering to time it. PERSIST mode is new to me so i can't say anything about that.

OSW handles this by releasing the handles after the file system is idle for some period of time. This works, but I don't like it.

FWIW, i don't either (and i'm the one who implemented it) ;). It's a stopgap measure until we can find something better. To that end...
We now, in a branch, have a new OPFS-specific URI flag which will tell it to release "implicit locks" at the end of the operation which acquires them. (That will be merged into trunk sometime today or tomorrow.) This approximately doubles our "reliable" concurrency levels in very basic tests but has a huge performance hit on I/O-heavy tasks (taking as much as 400% longer to run with zero contention). That flag eliminates the idle-time closing of sync handles but the performance hit of reacquiring the sync handle for every op which uses it sucks. (Sidebar: we had very specific performance requirements going into this, imposed by an Influential Third Party, and we shamelessly optimized to hit those. Resolving contention was a secondary concern which currently has priority.)

My preferred fix would be to acquire the handle for a main database journal in xOpen on the journal file if the main database is locked and in xLock on the database file, and to release the handle in xUnlock on the database file or xClose on the journal file. @sgbeal considers this be an ugly hack. I don't because the journal naming scheme is documented and the xOpen flags identify the type of file (so you can't be fooled by a database file named "foo-journal", for example).

i do consider it ugly but admittedly only on the grounds of aesthetics. i have no compelling technical argument against it and wouldn't lose too much sleep over implementing something like that. Right now the OWS data structure doesn't have any cross-file-handle mapping, e.g. main-db-to-journal, but such a thing could be added without much hassle. i will definitely put that down on the list of things to experiment with.

Another alternative fix would be to use BroadcastChannel ...

That's a new term for me, so i'll need to research that.
THANK YOU for your exhaustive response. This will give me much to mull over and experiment with for the near-term future.


Add support for IANA MIME Media Types

Sorry for all the commits - I'll be better next time :smile:

add a update command to update IANA-supported MIME types to the package
travis & tox tweaks

Coverage decreased (-0.31%) to 97.67% when pulling 16ac26e12790e81134bf930f64f440fb1528bd89 on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling 16ac26e12790e81134bf930f64f440fb1528bd89 on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling 16ac26e12790e81134bf930f64f440fb1528bd89 on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling 16ac26e12790e81134bf930f64f440fb1528bd89 on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling 16ac26e12790e81134bf930f64f440fb1528bd89 on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling d4c4af786886a5ca54254f676638bb2b9fa6047a on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling d4c4af786886a5ca54254f676638bb2b9fa6047a on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling d4c4af786886a5ca54254f676638bb2b9fa6047a on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.

Coverage decreased (-0.31%) to 97.67% when pulling d4c4af786886a5ca54254f676638bb2b9fa6047a on econchick:master into f29148c97f492ca0cfec560d468fd566f0f28fed on spotify:master.


error during deploy

I tried to deploy existing web server to vercel rust.
https://github.com/nosovk/iptoasn-webservice
And seems that proposed versel.json is incorrect
Error: Function Runtimes must have a valid version, for example<EMAIL_ADDRESS>With runtime config like https://github.com/nosovk/iptoasn-webservice/blob/master/vercel.json
Should be usage of community provider declared somewhere else?

It works for now with config in a repo updated.
P.S. adding links to some example repos will be nice. For example, handling of routes inside rust needs additional configuration (see config in previous post)


change workflow trigger

resolves #8414
docs dbt-labs/docs.getdbt.com/#
Problem
PRs that were merged before the workflow were not generating issues.
Solution
Trigger off pull_request_target.
Checklist

[ ] I have read the contributing guide and understand what's expected of me
[ ] I have run this code in development and it appears to resolve the stated issue
[ ] This PR includes tests, or tests are not required/relevant for this PR
[ ] This PR has no interface changes (e.g. macros, cli, logs, json artifacts, config files, adapter interface, etc) or this PR has already received feedback and approval from Product or DX

Failing test is being resolved by #8433.  Merging this now to prevent any more PR merges with failing tests.


vim difficult to navigate

Hi,
Whenever I'm trying to do a System.out.println() to debug on vim, the output is too long such that vim is not able to scroll up to view the top output. Anyone have any suggestions to get around this?

install a JDK debugger u can find it on the wiki tab
some vim shortcuts are: o (open new line), g,h,j,k instead of arrow keys to move between lines, :tabedit to view multiple tabs, gt to switch between tabs

to debug the continuous output of loops, try adding a break or continue statement!

install a JDK debugger u can find it on the wiki tab some vim shortcuts are: o (open new line), g,h,j,k instead of arrow keys to move between lines, :tabedit to view multiple tabs, gt to switch between tabs

I think it is h,j,k,l instead of arrow keys
The tabedit is really really really helpful! Thanks a lot for sharing that!

you can actually zoom out and open up 2 windows of the same file to display output by "pages"


SCSS is not getting detected

We have written the needed data into your clipboard because it was too large to send. Please paste.
there is an error when i write sass code in *.scss files :
$ shows error message at-rule or selector expected
: shows error message { expected

We only support SCSS with curly brackets.
For the indentation based SASS you need to look in the Marketplace for a SASS extension.


Fix memory inefficiency for baseline (GPTQ) configuration

This PR resolves an issue found by @poedator : the GPTQ baseline with very large group size would previously try to find outliers - and waste memory doing so - even though the outlier threshold is infinite

lgtm


Can't show point marker with old phone

Describe the bug
I can't show the point marker with the old phone or some cellphone with old camera
Desktop (please complete the following information):

OS: android
Browser: chrome
Version [e.g. 22]

Additional context
Add any other context about the problem here.

please open a new issue filling it at least with device version, and android version (also chrome if possible).


CategoryOrderHints using externalId instead of category.id

This PR adds two new parameters

--categoryOrderHintBy  will let us export categoryOrderHints with category extrenalId instead of category id as requested here #154
--mergeCategoryOrderHints will merge old and new categoryOrderHints instead of replacing them with new values.

Coverage increased (+0.06%) to 89.043% when pulling 461a5d56e7dcb44836eb3339974d07e779d0d9c2 on issue-154-category-order-hints-by-external-id into fc040cfb74d01043526a6e945fe3db74bd7f67b7 on master.

Coverage increased (+0.1%) to 89.126% when pulling a49fb257110b401f06644c6447ddf34f82d21c94 on issue-154-category-order-hints-by-external-id into fc040cfb74d01043526a6e945fe3db74bd7f67b7 on master.

This should be two separate PRs... But well let's at least keep the commits intact when merging.
Having trouble getting the tests to run, it just get's stuck in an endless loop. 🍝

Coverage increased (+0.1%) to 89.126% when pulling 033fe13f7831473f0daf934f4fdd80af86188094 on issue-154-category-order-hints-by-external-id into fc040cfb74d01043526a6e945fe3db74bd7f67b7 on master.

Hello @hisabimbola, @Siilwyn - Is there anything needed here in this PR? It is finished on my side.

Coverage increased (+0.1%) to 89.126% when pulling f95283e44f22c02e5482d22da50d0e82bfa7255c on issue-154-category-order-hints-by-external-id into fc040cfb74d01043526a6e945fe3db74bd7f67b7 on master.

@hisabimbola can you please check this PR if we can merge it?


DOC-2413: Add note about unsupported syntax

Fixes DOC-2413

This change is

Oops, wrong branch name.


Wrong protobuf files examples

All the protobuf files miss ; from their first line, version declaration, i.e.:  syntax = "proto3";

Document Details
⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

ID: c2a41d02-3084-c31e-98ed-2bd786c7a301
Version Independent ID: 31a20696-f326-63c3-77d1-f3cfc0aa589c
Content: Protobuf scalar data types - gRPC for WCF Developers
Content Source: docs/architecture/grpc-for-wcf-developers/protobuf-data-types.md
Product: dotnet-architecture
Technology: grpc
GitHub Login: @markrendle
Microsoft Alias: nanil

@markrendle can you look at this issue?

Tagging @shirhatti here


Animation: Silence false positive -Wstringop-overflow warning

And disable debug code which was wrongly left enabled.
@marxin I don't know if that's an expected false positive from GCC, or a situation which is still risky enough (while being correct in this case) to warrant warning just in case. I reduced it to this:
#include <cstdint>
#include <cstdio>

uint32_t some_func(const uint32_t components) {
	uint8_t header[8];
	uint32_t header_bytes = 0;
	for (uint32_t i = 0; i < components; i++) {
		header_bytes += 2;
	}
	header_bytes += 2;
	// This works it around, but shouldn't be needed AFAICT.
	//while (header_bytes != 8 && header_bytes % 4 != 0) {
	while (header_bytes % 4 != 0) {
		header[header_bytes++] = 0;
	}
	for (uint32_t i = 0; i < header_bytes; i++) {
		printf("%d\n", header[i]);
	}
	return header_bytes;
}

int main() {
	some_func(1);
	some_func(3);
	return 0;
}

$ g++ main.cpp -O3 -Wstringop-overflow=2
main.cpp: In function ‘uint32_t some_func(uint32_t)’:
main.cpp:14:40: warning: writing 1 byte into a region of size 0 [-Wstringop-overflow=]
   14 |                 header[header_bytes++] = 0;
      |                 ~~~~~~~~~~~~~~~~~~~~~~~^~~
main.cpp:5:17: note: at offset 8 into destination object ‘header’ of size 8
    5 |         uint8_t header[8];
      |                 ^~~~~~

It doesn't happen with lower levels of optimization (and happens with any level of -Wstringop-overflow=).

I've just reported the false positive here:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104789
Note the warning has non-zero false positive rate :P

@akien-mga: Can you please reply to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104789#c3 ?

@akien-mga: Can you please reply to gcc.gnu.org/bugzilla/show_bug.cgi?id=104789#c3 ?
I'm not familiar with the term "bounded roo". I reduced the test case as much as I could to focus on the minimal code that would trigger the warning which seems to me like a false positive - is it not one?
I can try to include all the relevant code to do marshalling but it seems to me that it will just make the test case more complex - while the minimal one does reproduce an issue.

All right, so please reply it to the GCC bug.


Replaced broken link to Java example with working one.

Accessing
https://raw.githubusercontent.com/rabbitmq/rabbitmq-java-client/master/test/src/com/rabbitmq/examples/ConfirmDontLoseMessages.java
returned a 404 Not Found.
Replaced it with
https://raw.githubusercontent.com/rabbitmq/rabbitmq-java-client/master/src/test/java/com/rabbitmq/examples/ConfirmDontLoseMessages.java
to make it work again.

Thank you!


Extend IntegrationEvent in Table 60 "Document Sending Profile", function OnBeforeSendEmailToCust

Hello,
please extends IntegrationEvent in Table 60 "Document Sending Profile", function OnBeforeSendEmailToCust.
Existing Parameter "ShowDialog" should have the VAR Property.

Thanks for reporting this. We agree, and we’ll publish a fix asap, either in an update for the current version or in the next major release. Please do not reply to this, as we do not monitor closed issues. If you have follow-up questions or requests, please create a new issue where you reference this one.


Fetch plan fails when part of query

OrientDB Version, operating system, or hardware.

v2.2.10

Operating System

[x] Linux
[x] MacOSX

Expected behavior and actual behavior
Expected to get the query results with fetched linked objects when executing a query with or without parameters. However, the resulting object (JSON) is returned with @rids instead of the actual linked objects. The only way I can get linked objects is at the time of toJson("fetchPlan:...."). But, I believe it will call the remote database second time, which unnecessary creates latency.
Steps to reproduce the problem
CLASS 'LeadCategory'
PROPERTIES
+----+--------------+-------+------------+---------+--------+--------+----+----+-------+-------+
|#   |NAME            |TYPE   |LINKED-TYPE/CLASS|MANDATORY|READONLY|NOT-NULL|MIN |MAX |COLLATE|DEFAULT|
+----+--------------+-------+------------+---------+--------+--------+----+----+-------+-------+
|0   |presetAttributes|LINKSET|PresetAttribute  |false    |false   |false   |    |    |default|       |
|1   |className       |STRING |                 |true     |false   |true    |    |    |default|       |
|2   |id              |INTEGER|                 |true     |true    |true    |    |    |default|       |
+----+--------------+-------+------------+---------+--------+--------+----+----+-------+-------+
Here are few failing queries:
Query 1 - Fails
List result = db.query(new OSQLSynchQuery("select from LeadCategory where id = 1").setFetchPlan("*:-1"));
result.get(0).toJSON();
It produces the following json
{"@type":"d","@rid":"#45:1","@version":1,"@class":"LeadCategory","id":1,"className":"TempLead","presetAttributes":["#80:0","#79:0"],"@fieldTypes":"presetAttributes=n"}
Query 2 - Fails
String sql = "select from LeadCategory where id = ?";
OSQLSynchQuery query = new OSQLSynchQuery<>(sql);
query.setFetchPlan("*:-1");
List result = db.command(query).execute(categoryId);
result.get(0).toJSON();
It produces the same json
{"@type":"d","@rid":"#45:1","@version":1,"@class":"LeadCategory","id":1,"className":"TempLead","presetAttributes":["#80:0","#79:0"],"@fieldTypes":"presetAttributes=n"}
Query 3 - Succeeds
String sql = "select from LeadCategory where id = ?";
OSQLSynchQuery query = new OSQLSynchQuery<>(sql);
List result = db.command(query).execute(categoryId);
result.get(0).toJSON("fetchPlan:*:-1");
produces correct json
{"id":1,"className":"TempLead","presetAttributes":[{"name":"utilityCompany","values":["American Electric Power","Azusa Light & Water","Black Hills Energy","Bryan Texas Utilities","California Public Utilities Commission","Central Maine Power","City & County of San Francisco","Duke Energy Indiana","Excel Energy","Georgia Power","Guadalupe Valley Electric Cooperative","High West Energy"]},{"name":"contactTime","values":["anytime","morning","afternoon","evening"]}]}
So, that was problem #1.
Also, as a problem #2, I spotted that I can't attach the fetch plan like in your docs example in the fluent function manner:
OSQLSynchQuery query = new OSQLSynchQuery<>(sql).setFetchPlan("*:-1");
Instead, I had to split the functions, which didn't work (as per problem #1 above), like:
OSQLSynchQuery query = new OSQLSynchQuery<>(sql);
query.setFetchPlan("*:-1");
Let me know if I'm doing something wrong. This is my first time playing with fetching :)

Hi @borov333,
did you try to use the fatchplan inside the query ?
ex: String sql = "select from LeadCategory where id = ? fetchplan *:-1";
Bye

Unfortunately, it failed too. The resulting json is still the same:
{"@type":"d","@rid":"#45:1","@version":1,"@class":"LeadCategory","id":1,"className":"TempLead","presetAttributes":["#80:0","#79:0"],"@fieldTypes":"presetAttributes=n"}

hi @borov333,
I Just reread the issue, the fetchplan in the query has nothing to do with the way the json will be generated, they are two different api, the fetch plan in the query let you choose how much data connected to the results you have to download to the client, the fetch plan in the toJson let you to choose how much data connected to the result you want in the result include in the json.
Se everything work as expected, and for your case i guess you need both of them, first to download the data, second to generate the json.
Hope it help,
Bye

Hi Tglman,
I did a pretty dumb test, I hope I did it right. I added the fetch plan to the query to pull the records and closed db connection to make sure we don't go back. Then I called the toJson to get the actual JSON. I got an error. When I called toJson it wants to go back to the db and pull the records by the defined fetch plan. So, it is not acting as explained in the manual that fetch plan avoids extra trips to the database. Either I'm doing something wrong or there is a possibility for a bug?
Here is FAILING logic.
List<ODocument> result = null;
try (ODatabaseDocumentTx db = DbPool.getConnection()) {
    String sql = "select from LeadCategory where id = ? fetchplan *:-1";
    OSQLSynchQuery<ODocument> query = new OSQLSynchQuery<>(sql);
    result = db.command(query).execute(categoryId);
}

// this call toJSON(...) results in error below
System.out.println("JSON = "+ result.get(0).toJSON("fetchPlan:*:-1"));

SEVERE: Fetching error on record #45:1
com.orientechnologies.orient.core.exception.ODatabaseException: The database instance is not set in the current thread. Be sure to set it with: ODatabaseRecordThreadLocal.INSTANCE.set(db);

In my understanding the results are already pulled from the database and should be available in the List, but it's not the case. toJson(...) wants to go back to the db.
Here is WORKING logic, but it comes without anything fetched in the query
List<ODocument> result = null;
try (ODatabaseDocumentTx db = DbPool.getConnection()) {
    String sql = "select from LeadCategory where id = ? fetchplan *:-1";
    OSQLSynchQuery<ODocument> query = new OSQLSynchQuery<>(sql);
    result = db.command(query).execute(categoryId);
}

System.out.println("JSON = "+ result.get(0).toJSON());

The result is:
JSON = {"@type":"d","@rid":"#45:1","@version":1,"@class":"LeadCategory","id":1,"className":"TempLead","presetAttributes":["#80:0","#79:0"],"@fieldTypes":"presetAttributes=n"}
Here is WORKING logic, but it fetches records on a second db call :(
try (ODatabaseDocumentTx db = DbPool.getConnection()) {
    String sql = "select from LeadCategory where id = ?";
    OSQLSynchQuery<ODocument> query = new OSQLSynchQuery<>(sql);

    List<ODocument> result = db.command(query).execute(categoryId);
    System.out.println("JSON = "+ result.get(0).toJSON("fetchPlan:*:-1"));
}

The result is:
{"id":1,"className":"TempLead","presetAttributes":[{"name":"utilityCompany","values":["American Electric Power","Azusa Light & Water","Black Hills Energy","Bryan Texas Utilities","California Public Utilities Commission","Central Maine Power","City & County of San Francisco","Duke Energy Indiana"]},{"name":"contactTime","values":["anytime","morning","afternoon","evening"]}]}

hi @borov333,
I'll explain it in an easy way: the fetch plan in the query download the records and put them in the database local cache, the toJSON when it generate the nested json look for the records in the database local cache.
so if you do a toJSON with fetchplan and there is no database open in the current context it will complain.
If you don't use the fetchplan in the query, the toJSON will look on the server for the records.
the right solution is to use both and do the toJSON inside the try{}
Hope it help.
Bye

It makes sense now. I re-read the docs and it says:

OrientDB loads all connected records into the local client, meaning that the collections remain lazy, but when accessing content, the record is loaded from the local cache to mitigate the need for additional connections.

I think what confused me was that if it's in the local client's cache then I won't need to keep the connection with the db, but I guess it needs it to be able to pull these records from the client's cache.
Thanks for the details tglman.

Hi,
No problem, can we close this ?
bye

Yes, please.


Dropped support for installing Ghost via npm

Summary
While troubleshooting storage adapter issues, I encountered a comment from the Ghost staff indicating dropped support for installing Ghost via npm.  It's unknown how this might impact this project at this time.
Problem
Unknown
Impact
May have development/deployment implications
Solution
Unknown
Detail
Screenshots

Additional context
Via: https://forum.ghost.org/t/ghost-npm-module-contentpath-for-storage-adaptors/6288/9

I don’t think we need to do anything with this unless it stops working completely.
Even then, a bash script on deploy may solve this by running Ghost locally.


Improving backend file structure

I think we need a better folder structure in order to implement testing and to get ready to increase the codebase,
this is not completed because I removed several things in the server.js and this is a suggestion if this suggestion like you maybe I can add the other things,
I followed up this post

@JuanVqz
This is awesome, this will be really great for the project. 👍
I will assign this you, go ahead and work on this.
No rush, take your time.

@lelouchB  The old stuff we had when I started changing the structure are working now but I need to fix those conflicts, this is a little update to let you know how we are in the process

@lelouchB Would you make sure this is working as expected, please?

@lelouchB Would you make sure this is working as expected, please?

Ofcourse
I will get to it this weekend.

@lelouchB if the change doesn't like you at all, I can leave it and work on the testing issue. :+1:

Hey @JuanVqz
I didn't had the time to go through it last week, kind of busy these days.
Sorry for the delay.
I will try to get to it as soon as possible.
In the meantime you can work on testing.
Thanks


Docker in user context

CLI plugins are installed to ~/.local/libexec/docker/cli-plugins

[x] Link to this location from ~/.docker/cli-plugins

Resolved using path rewrites in uniget-org/cli#285


openssl req: Interactively specify subjectAltName (SAN)

Firefox & Chrome now require the subjectAltName (SAN) X.509 extension for certificates.
Please provide a way to specify the SAN interactively (along the CN) when generating certs & reqs using the openssl command line tool (openssl req).

[ .. ]
Common Name (eg, fully qualified host name) []: mydomain.com
Subject Alternative Name (eg, list of host names) []: mydomain.com,www.mydomain.com
[ .. ]

A PR would help expedite this.
You can also use the $ENV construct in your config file and set the SAN field in the environment.

My assumption is there are two separate requirements here:

Copy the CN value to the default SAN DNS value, and
Additionally capture a list of additional SANs, appending these to the default SAN.

If I've understood the requirement correctly? Is part 1. partially addressed by PR #341?

@richsalz the $ENV approach adds unnecessary complexity and also makes the scripts harder to be cross-platform. Plus it still requires even having a .conf file ...

Sure, it's sub-optimal.  See the other part of my comment :)

Is this "true"? https://certsimple.com/blog/openssl-csr-command
These guys say that I can use -subj '/CN=example.com/subjectAltName=DNS.1=example.com, DNS.2=www.example.com but I can't seem to get such syntax working on version 1.1.0g on Debian Stretch.

@JamesTheAwesomeDude, I would say that's possible if the signing CA knows to pick out subjectAltName from the csr's subject and make an extension of it. I don't know any CA that does this, though...

Yeah, it doesn't create the appropriate "Subject Alternative Name" field, it just adds it to the "Subject" field, which isn't where it should be.

Many commercial CA's add the CN field to the SAN extension, but not all.  And as others pointed out, it is not added to the CSR.

Just wanted to say thanks so much for bfa470a4f64313651a35571883e235d3335054eb and resolving this Issue
Looking forward intensely to its inclusion in Debian. This will make manual CSR generation so much less painful!


Only produce ConcurrentValue-related diagnostics under -warn-concurrency

@swift-ci please smoke test and merge


Fix the presence indicator not working anymore

As can be seen in eg #1242 the presence indicator does not work currently. This is caused by a few different issues, for one they did some server-side changes to some object names, causing the initial presence loading to not work. They also completely removed the presence value from the server event, and it is instead replaced by a null. I fixed this by instead relying on the timestamp in that message, which will be checked against the self presence timestamp and if it's older than an offset (15 minutes currently because that seems to be what it is in the web app) the user will be marked as not present.

Looks really good!


Catch up to latest jQuery commits

That's correct... it being a jQuery fork, there's a default template that I didn't bother to delete or remove.


Feature Request: Let tf.contrib.image.transform supports half type

Currently tf.contrib.image.transform doesn't support half type. It is great if it can support. Thanks.
@ringw

@x10000year I added a PR #20249 for float16 type support with tf.contrib.image.transform.


[PE-D][Tester B] Does not allow different patients with same names

Should be parsing duplicate data using ID instead of name as names of the patients can be the same but ID is the unique distinguishing factor. Here, I tried adding a patient with the same name but different id and other attributes but could not be added.
I reported bug as medium because if this system is implemented on a very large scale in a massive database, there is a relatively high probability of same names, which the system would not allow to be added.

Labels: severity.Medium type.FunctionalityBug
original: RiyaMehta2211/ped#1

This is a feature flaw that we are unable to fix in this milestone. We plan to be able to handle duplicate names in the future - this will be in our DG.


Create NOTICE file at the top of the source directory

From Alan Gates

Create NOTICE file at the top of the source directory, see
https://incubator.apache.org/guides/releasemanagement.html and
http://www.apache.org/legal/release-policy.html

Resolved by #6496


Upload test results artifact

Add a stage to CI to upload the test results as an artifact.
This could then be used by Danger to produce warnings if need be.

This is now done.


Removed ubuntu 18.04 workflow and added ubuntu 22.04

Removed ubuntu 18.04 workflow
~Added ubuntu 22.04 workflow~

Removed CI for Ubuntu 22.04 with ros noetic because there is a compatibility issue in rosconsole between different versions of liblog4cxx: https://github.com/ros/rosconsole/pull/58

Removed CI for Ubuntu 22.04 with ros noetic because there is a compatibility issue in rosconsole between different versions of liblog4cxx: ros/rosconsole#58

You mean Ubuntu 18.04 with ros melodic?? Otherwise LGTM

Removed CI for Ubuntu 22.04 with ros noetic because there is a compatibility issue in rosconsole between different versions of liblog4cxx: ros/rosconsole#58

You mean Ubuntu 18.04 with ros melodic?? Otherwise LGTM

I indeed tried to add an Ubuntu 22.04 workflow, but decided to remove it due to the complexity of installing ros noetic on ubuntu 22.04.


Update Makefile

curl -o ${IMAGE}.sig https://www.archlinux.org/iso/${VERSION}/${IMAGE}.sig
had failed with "gpg no valid openpgp data found. gpg the signature could not be verified" because it was HTML telling about "forbidden"

Thanks! I'll also add -L to instruct curl to follow redirects in future.

Thanks! I'll also add -L to instruct curl to follow redirects in future.


Recent Events (timeline) within case summary

Make sure you check the travis build too. Looks like the Universal build is failing.

LGTM


feat: configure logger to skip debug messages by default

Pull request
Please confirm that this pull request has done the following:

[ ] Tests added
[x] Documentation added (where applicable)
[ ] Description in a {pr}.thing.md file in the directory changelog added - see changelog/README.md for details

Description

Add documentation about the logging
Configure the default logger to skip debug messages

Yay, I also repaired the readthedocs integration, it was broken due to the move to primap-community.


Patient details updates

Updates to patient details including:

[x] formatted many-to-one fields using .form_multiform class
[x] many-to-one styles for mobile
[x] all many-to-one fields updated and tested
[x] update buttons across patient details page
[x] update titles/headers spacing on patient details page

Many-to-one field styles!

Alright, this PR is ready to merge! Testing many-to-one fields worked nicely except for deleting addresses because of a check in views.py that looks for the state as set to VA, which is unrelated to these changes. @esmithayer said she would take a look - and I added as a micro-task in #183

nice :+1:


Azure Plugins

We are building Azure Plugins.
https://github.com/nmondal/cowj/issues/107

Pending works are adding tests and documentation. Also KeyVault has issues.


#FR CG pipeline in tf

#in brief
build computer graphic render pipeline with tf
In GDC2017's talk 'FrameGraph: Extensible Rendering Architecture in Frostbite', a few slide inspire me, why don't CG and CV use the same computation platform, share 'GPU cluster' 'memory management' and 'operation oplimization' code, iteract with each other directly.  I am going to implement a simple ray trace with tf, is there any comment or suggestion?

This seems very speculative and this is not supposed to be a discussion forum.
I suspect that your question is better asked on StackOverflow. There is also a larger community that reads questions there.
Please feel free to reopen once you have more specifics.


Allow additional principals (e.g. domain names for hosts) to be specified in key signing req

Needed for SSH bastions, maybe for other things too?

Completed in 0.0.4


Data set preprocessing

Hello, I am a graduate student who is very interested in the topic of multimodal fusion. After reading your paper and source code, I find it very exciting and I am very interested in your ideas on multimodal fusion. However, I met some problems in the experimental reproduction stage, and I don't know how you integrated multiple modes into a single mode in the data set preprocessing stage. I wonder if you could give me some advice. Thank you very much, and I look forward to your reply in your busy schedule. Thank you very much!

Thank you for your interest in our work and for taking the time to reproduce our experiments. I’m glad to hear you found our paper and code exciting! Regarding your question on multimodal data preprocessing, here’s how we approached it:
In our implementation, we concatenated the multimodal data during the preprocessing stage to form a single image, which was then fed into the model. Inside the model, we split this concatenated input back into its original modalities for separate processing. This approach was mainly due to limitations in the version of MMSegmentation we used, which lacked convenient support for reading multiple modalities directly.
If you’d like a more streamlined way to handle multimodal images, I recommend using the latest version of the MMSegmentation framework. It now provides enhanced support for reading and processing multiple images simultaneously, which could simplify your workflow significantly.

Thank you very much for your reply. Under your prompt, I processed the whu-opt-sar data set. I used the script to make the opt image with the same name into (3704, 5556, 4) and the sar image into (3704, 5556,5), and the result after stitching is (3704, 5556,5). However, the channel error is still displayed, I am very puzzled, and I hope you can give me more details about the data set preprocessing method. I look forward to your reply. Thank you very much.


DuplicateFieldName in user collection

Link to reproduction

Describe the Bug
When I declare a field that already exists in user collection to merge settings with mine the build process stop to report the following error:
DuplicateFieldName: A field with the name 'email' was found multiple times on the same level. Field names must be unique.
This way to extend the native fields worked with the previous version ("payload": "2.4.0")
To Reproduce

Add the user collection in the config

const Users: CollectionConfig = {
	slug: "users",
	auth: true,
	fields: [
		{
			name: "email",
			type: "email",
			label: "Email",
			access: {
				read: ({ req, id }) => {
					// Extend logic
					const isAdmin = accessUserWithRole(req.user, "admin");
					const isSelf = accessCurrentUser(req.user, id);
					return isAdmin || isSelf;
				},
			},
		}
	],
}

install dependencies yarn install
Execute the build npm run build
The build stop with the error

Payload Version
"payload": "2.8.2",
Adapters and Plugins
"@payloadcms/bundler-webpack": "1.0.6", 		"@payloadcms/db-mongodb": "1.3.2", 		"@payloadcms/plugin-cloud-storage": "1.1.1", 		"@payloadcms/plugin-form-builder": "1.2.0", 		"@payloadcms/plugin-nested-docs": "1.0.11", 		"@payloadcms/plugin-seo": "2.2.0", 		"@payloadcms/richtext-lexical": "0.5.2", 		"@payloadcms/richtext-slate": "1.3.1",

I tried this on latest v2.8.3 and didn't have any trouble using this as my users collection:
const Users: CollectionConfig = {
  slug: 'users',
  auth: true,
  fields: [
    {
      name: 'email',
      type: 'email',
      required: true,
      access: {
        read: () => true,
      },
    },
  ],
}

I didn't use all the plugins you mentioned, though that should be irrelevant.

@DanRibbens
I found the problem, is the seo plugin, the tabbedUI setting. With the followind minimal configuration the error is still visible. Without the "TabbedUI" it works.
export default buildConfig({
    db: mongooseAdapter({
        url: process.env.MONGODB_URI,
        connectOptions: {},
    }),
    editor: lexicalEditor({}),
    admin: {
        bundler: webpackBundler(),
    },
    collections: [
        {
            slug: "users",
            auth: true,
            fields: [
                {
                    name: "email", // required
                    type: "email", // required
                    required: true,
                    access: {
                        read: () => true,
                    },
                }
            ],
        },
    ],
    plugins: [
        seo({
            collections: ['users'],
            tabbedUI: true, // This is the problem
            fields: []
        })
    ],
})

I report the full error message
DuplicateFieldName: A field with the name 'email' was found multiple times on the same level. Field names must be unique.
    at /Users/matteotortelli/progetti/evoluzione/evoluzione-backend/node_modules/payload/dist/fields/config/sanitize.js:81:23
    at Array.map (<anonymous>)
    at sanitizeFields (/Users/matteotortelli/progetti/evoluzione/evoluzione-backend/node_modules/payload/dist/fields/config/sanitize.js:25:19)
    at sanitizeCollection (/Users/matteotortelli/progetti/evoluzione/evoluzione-backend/node_modules/payload/dist/collections/config/sanitize.js:135:53)
    at /Users/matteotortelli/progetti/evoluzione/evoluzione-backend/node_modules/payload/dist/config/sanitize.js:81:85
    at Array.map (<anonymous>)
    at sanitizeConfig (/Users/matteotortelli/progetti/evoluzione/evoluzione-backend/node_modules/payload/dist/config/sanitize.js:81:45)
    at buildConfig (/Users/matteotortelli/progetti/evoluzione/evoluzione-backend/node_modules/payload/dist/config/build.js:18:62)
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
    at async loadConfig (/Users/matteotortelli/progetti/evoluzione/evoluzione-backend/node_modules/payload/dist/config/load.js:30:34) {
  data: null,
  isOperational: true,
  isPublic: false,
  status: 500
}

@DanRibbens any updates?


[#4201] Consider using builder pattern to construct DomainNameMapping.

Made an immutable implementation of DomainNameMapping;
Added Builder for immutable DomainNameMapping;
Replaced regex pattern with String::startsWith check;
Replaced HashMap with two arrays in ImmutableDomainNameMapping;
Deprecated mutable API;
Unit tests.

@eantaev Nice work! Could you please address the comments? Also, please sign the ICLA if you did not yet: http://netty.io/s/icla

@trustin, ok, done.

@normanmaurer I fixed all the issues and added buffer size estimation.

@eantaev Thanks a lot! I think we are almost there. Left a few trivial comments.

@trustin ok, done.

@eantaev can you just squash the commits into one ?

@normanmaurer sure. Done

@Scottmitch right. Changed it.

@eantaev once you signed our ICLA I will cherry-pick this change: http://netty.io/s/icla
Let me know once done and thanks!

I have already signed it.

Ah sorry, missed it...

@eantaev sorry to be a pita... one last favour to ask. Can you just update your commit message to match our commit message template before I cherry-pick:
http://netty.io/wiki/writing-a-commit-message.html

@normanmaurer no problem

Thanks again @eantaev
Cherry-picked into 4.0 (eca67ee9721c8093b87ac1008eb11804f007382a) and 4.1 (7c1602125a94583c3004cb30ead329845c2a679c)


MSID: 93520 Version: 1 DOI: 10.1101/2<IP_ADDRESS>6234

MSID: 93520
Version: 1
Preprint DOI: https://doi.org/10.1101/2<IP_ADDRESS>6234
Step 1. Awaiting reviews
Editorial to post reviews via hypothesis
Useful links:

DocMap: https://data-hub-api.elifesciences.org/enhanced-preprints/docmaps/v2/by-publisher/elife/get-by-manuscript-id?manuscript_id=93520
New model tracking: https://docs.google.com/spreadsheets/d/1_fHaoOy7hjyocptKtVJRijeNpUY4hBS7Ck_aVmx6ZJk/
Reviews on sciety: https://sciety.org/articles/activity/10.1101/2<IP_ADDRESS>6234

For trouble shooting (e.g. no Docmaps available):

DocMap issue addressing: https://miro.com/app/board/uXjVNCwK6EI=/
Explore DataHub DocMaps API: https://lookerstudio.google.com/reporting/4c2f0368-babb-4beb-b5b3-497e7e7b0f08/page/ejphD
Unmatched submissions and preprints: https://lookerstudio.google.com/u/0/reporting/9f86204f-3bf7-477c-9b18-5c5ef141bf69/page/p_gxi57ha93c
Unmatched manuscripts spreadsheet: https://docs.google.com/spreadsheets/d/15QcK8w-ssB7109RQEDtFpJPZ0J5HTGxoHa_2TtpMBbg/edit#gid=1336081641

Step 2. Preview reviewed preprint
Production QC content ahead of publication
Instructions:

QC preview: https://prod--epp.elifesciences.org/previews/93520v1
Update ticket with any problems (add blocked label)
Add publication date and time to https://docs.google.com/spreadsheets/d/1amAlKvdLcaDp5W8Z8g77NmkwbMF5n_u89ArSqPMO8jg
Move card to next column
(At end of the day post link in #enhanced-preprint and ask for PDF to be generated)

Useful links:

Preprint DOI :  https://doi.org/10.1101/2<IP_ADDRESS>6234
Confirm reviews returned by EPP: https://prod--epp.elifesciences.org/api/reviewed-preprints/93520/v1/reviews
To update the MECA path in the docmap: https://docs.google.com/spreadsheets/d/1mctCQuNFBjSn97Lihy7_vBO6z7-N-oqyLv4clyi6zHg

Step 3: Awaiting search reindex
This step adds the reviewed preprint to the homepage: https://elifesciences.org
The search reindex is triggered once an hour. We need the reviewed preprint to be indexed as the search application serves the journal homepage.
Useful links:

Jenkins pipeline to reindex search can be triggered sooner or monitored here: https://alfred.elifesciences.org/job/process/job/process-reindex-reviewed-preprints/

Step 4: Published! PDF requested
Waiting for PDF to be generated
Useful links:

PDF tracking: https://docs.google.com/spreadsheets/d/106_XeDjmuBae7gexOTNzg60lapeqjl2aRn9DzupGyS8/

Step 5: Introduce PDF to data folder and git repo
Detailed instructions: https://github.com/elifesciences/enhanced-preprints-data#add-a-pdf
Step 6: Add PDF url to manuscripts.json
Pull request created to enhanced-preprint-client

Instructions to add PDF url to manuscripts.json

Visit: https://github.com/elifesciences/enhanced-preprints-client/actions/workflows/add-pdf-url-to-manuscript.yaml
Click: Run workflow
Complete the form and click "Run workflow"
A successful run should result in a new pull request at https://github.com/elifesciences/enhanced-preprints-client/pulls
Open the pull request and click the "Ready for review" button to trigger tests
Once the tests pass and you are happy with the changes the PR can be merged

Example pull request: https://github.com/elifesciences/enhanced-preprints-client/pull/397/files
Once the pull request is merged in it should be available a few minutes later.

Step 9: Done!

[ ] Kettle is on!

reviews unavailable

reviews unavailable

resolved


Regularize map zoom and pan behavior

Overview
Extract a useUpdateLeafletMapImperatively hook, then use it to adjust
the map components to have the following behavior on selecting a new
facility:
For the non-vector-tile FacilitiesMap:

[x] if the user clicks on a facility marker, do not pan & zoom to the
facility
[x] if the user arrives at the map directly from a URL containing an OAR
ID, set the map view on the facility location, zoomed to level 15
[ ] if the user clicks on a facility in the sidebar, do not pan & zoom to
the facility unless the selected facility is outside of the current map
viewport bbox when the details data returns

For the vector tile map:

[x] if the user clicks on a facility marker, do not pan & zoom to the
facility
[x] if the user arrives at the map directly from a URL containing an OAR
ID, set the map view on the facility location, zoomed to level 15
[x] if the user clicks on a facility in the sidebar and the selected
facility is outside of the bbox OR the zoom level is
within the range in which the facilities grid layer is shown, pan to the
facility and set the zoom level at 15. This ensures that the facility
details marker will be visible even if the map was at grid-layer zoom
levels before

Connects #757
Testing Instructions

serve this branch and use the app both in vector tile and non-vector tile modes to verify that it works according to the cases described above and that it addresses the spirit of #757

Checklist

[ ] fixup! commits have been squashed
[ ] CI passes after rebase
[x] CHANGELOG.md updated with summary of features or fixes, following Keep a Changelog guidelines

Looking at this now.

Oof, thanks for catching those discrepancies. I rebased this on develop and will work out the remaining issues.

Looking at this now.

With the vector grid off, when I select a facility from the sidebar the markers start blinking

I can't reliably reproduce the blinking issue. I have not seen it in Chrome. In Firefox the following steps sometimes trigger the blinking. It does not happen every time.

In Firefox...
Open a new tab to http://localhost:6543/
Click "Search"
Click the first item in the sidebar.

We discussed this but:
I decided to drop the changes to the existing FacilitiesMap and leave it in its current state. However, I kept the custom hook to regularize the vector tile map's zoom behavior which should still work as it did in the last test.

Looking at this now.

Cool! Thanks for your help with this.


Ledger description is still Amount(GTU) for multisig simple transfer

Bug Description
Ledger description is still Amount(GTU) for signing a multisig simple transfer. Should be Amount(CCD) instead.
Steps to Reproduce

sign a multisig simple transfer
run through transaction on Ledger

Expected Result
Ledger displays CCD.
Actual Result
Ledger displays GTU.
Versions

DW 1.3.1
Ledger CCD app 2.0.1
Ledger firmware 2.0.0

This has been changed to Amount (no unit) in 2.0.3. (which we only released for firmware 2.1.0)

As this has already been fixed in 2.0.3, and as it does not make sense to release a new version for the old firmware, I am closing this issue.


Complex parent/child relationships

stoQ currently only tracks the current uuid, and it's parent (puuid). As @rkovar discovered, this makes is extremely difficult to track parent/child relationships that have a deeper lineage. For instance, let's say we have a compressed file with the below structure:
bad.zip
  - setup.exe
  - morebadness.zip
    - myc2.scr

In order to understand where myc2.scroriginated from, one would have to query for the puuid for myc2.scr, and then the puuid of morebadness.zip just find determine that bad.zip is the original payload myc2.scr was found in. This becomes exponentially more complex with deeper payload relationships.
Ideally the puuid key should be removed, and the uuid key should be a list that is appended to when a new child payload is processed. For example:
{
      "payload_id": 10,
      "uuid": [
          "e05f3895-05be-48ca-987e-fd830218261f",
          "2b6d77c5-8024-42ff-a844-6387d11261cb",
          "48780584-b2ab-4db0-9d0a-9740976be872",
          "c0b9418e-36ea-4ccd-b5de-996a3a704bc6",
          "57247505-d506-4977-8f70-becc08a5dde8"
      ],
      ...
      "dispatcher": "carver:pe",
      "plugin": "yara",
      "size": 79360,
      "save": "True",
}

Fully implemented in b1880df


[router] Ignore path parameters when RouteConfiguration is configured

Commit Message: Add an option in RouteConfiguration, if enabled, ignore path-parameters (RFC1808) in path matching.
Additional Description:
Risk Level: LOW(default false).
Testing: unit test
Docs Changes:
Release Notes:
Platform Specific Features:
[Optional Runtime guard:]
[Optional Fixes #Issue] #21590
[Optional Fixes commit #PR or SHA]
[Optional Deprecated:]
[Optional API Considerations:]

/retest

/lgtm api

/retest