GitLab How Gitaly fits into GitLab, 21 Mar 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: How Gitaly fits into GitLab: Episode 5 – Merge Requests across Forks

Description

A 1-hour training video for contributors new to GitLab and Gitaly.

fixing a locally broken Ruby gem C extension by recompiling, demo of how creating a MR across forks causes new commits to suddenly appear in the fork parent repository, deep dive into the FetchSourceBranch RPC, adding debug code to see
how address and authentication metadata is passed down to
gitaly-ruby, failed attempt to log gitaly-ssh arguments, comparison
of gitaly-ssh and gitlab-shell, a Gitaly server can end up making RPC calls to itself.

Recorded 2019-03-21

A

Hello welcome everyone to I believe the fifth Catholic training session by now today, we're going to look at some things that happen during git merge and the perspective we're looking from is from AG Italy engineer, so someone who knows the quickly project but wants to understand how it fits into the larger picture of kit lab I think this is also interesting if you're looking at stuff from a different angle. But this is the angle when I approach it from so merge requests.

A

Let's, let's make a merge request and then I can point out the things that I want to look at. This is my GDK I hope we can see this and I have the gait lab test project here and I'm going to fork this, because things get more interesting when we work across Forks. So we just want to start out and that's scenario.

A

Maybe I don't remember if I have to feature flag turned on the nice thing about the way we implemented deduplication is that it doesn't really matter for anything I'm saying now: it's yeah! Well, maybe that's a topic for another time.

A

It shouldn't change. What happens now well in the future, the forks will be faster, so that will change what happens now. So we're not looking at a spinner okay there we are so I'm going to create a merge request and then point out some things, and that will lead me to do the topic so firsts.

A

So, let's create a merge, requests. I know in my fork, so my fork is in this group 3. If I change the URL to get lab org.

A

Go back to the parents.

A

Except that I or using not using the back button.

A

Okay, the back button, is also slow, well development mode. Okay, here we are so group three is the forked lap work is the original project that we forked from I'm going to edit a file? Let's say I want to edit the changelog. Maybe that's also a bad idea. If the change logo is long, it's probably not well, it's not long, because I guess I go for this file more often, if I want to edit something. The original content of the change mark was not misspelled. Whatever, let's fix the spelling and let's.

A

Put that on new branch.

A

How's, actually it will be interesting. No deduplication is not layoffs. What I want to say now.

A

No, what's that, why did we have a crash?

A

We have a crash symbol not found, and that is the reetou gem. Okay. Well, what do you do? You do Brundle pristine, Ritu.

B

This is a GE issue. It's.

A

An it's a yeah or a homebrew issue, homebrew randomly upgrade very eagerly Oakridge libraries and see extensions, then break, and so this is a guess. This is a little demonstration of troubleshooting. You need to find out where the problem is, and here I see that the gems called reads.

A

Ooh and something like simple not found to me sounds very C extension D and then the fix is to run bundle pristine and that gem in the directory of catalepsy a code base and that will reinstall it and now I have no idea how good life is going to recover.

A

Well, I have emerg requests or will that whole thing just have gotten lost.

A

Tell you already what I want to show I want to show that this editor gestates created a committee in the fork, but that committee does not exist in the parents. Actually, it's good that I didn't create the merge request straight away, because that would have brought me of the opportunity to show that the committee doesn't automatically go to the parents.

A

And so that that is what the one thing I want to show you ever commits in one project and how, when it gets merged, it eventually has to end up in the parent project. So how does it get there? And the other thing I want to look at is the fact that the merge commits has my name on it me, the user, and how does? How did that happen?

A

Where did that come from those are the two topics I want to look at and I'm still going to demonstrate it, because I think it's good to see this with your own eyes.

A

Are there any questions about this? This idea so far.

C

Why would creating the birth of Christ rob you of the idea of showing that the commit is not in the parent project? Good.

A

Question that is because, every once you have a merge request and everything on that branch that you're trying to merge and that gets added to it over time- well automatically gets fetched into the target projects.

A

So, let's, let's see if this already happens, probably not let's open a new tab with the repository and then I need to go to my branch, which was this branch.

A

I'm one come on.

A

So that's the commit I just made and let's see if that committee exists in the parent project already so here we have a commit. You are L and we're in group 3 I'm just going to change that group name and I get a 404. So thanks for the question- and so this was the first point- I wanted to make. We get a 404, um but I am going to curate. This Bert requests my favorite requests. It's not yeah.

A

A

B

C

You might have created it to the wrong project, correct.

A

C

A

Wonder what the default is or how am I supposed to make one across you're right? It's the wrong project. How do I create one across branches project.

C

Yeah, if you want to do it like magically like this, then you shouldn't have changed the branch name I think then it would automatically target I. Think I.

A

Don't know or maybe I go here, does it see that I pushed to my fork.

C

I and then create a merge request from their clever I.

B

A

Know if it does that maybe I lost that opportunity by creating the other merge requests.

A

Let's try again.

A

Let me just create it here: let's see, it should be possible.

A

Numerous requests I'm not sure if I can do it here, maybe I need to be on the other projects. No.

C

You can do it from here. Yeah thanks.

A

So I look for group three.

A

And much should be, mr one.

A

Okay, it isn't like that I.

C

Think you're signed in as moot probably.

B

So you just it's.

C

Something on the other project and in this drop-down thingy we only show things that you are actively a member of if I remember correctly, but.

A

I created that other fork myself so I should be the owner of it.

C

Isn't the group? Oh, it's.

A

A group yeah, but let's see if I, can do it see if I can do it from this side.

C

That should work.

C

A

Yes, magic all at once, so this should work. Let's stick with those immortal. Words submit merge, requests.

A

And yes, we're on good luck, work now, so here's the merch requests now remember. This is the window where I add the 404 on the commits I'm refreshing it now and I expect this two loads, because the commit now exists in the repository. So this is magic thing number one. The commits existed only existed in one repository now it's appeared in this one, even though we haven't merged yet now. The second thing is that when I merge.

A

A

If I go to the activity.

A

Maybe do these demos on only this instance, because that would be much faster, except I'm. Making life changes is a bit harder. So here it says, I just pushed to the master branch, but I didn't so. How did that end up there? And we saw in previous videos that these notifications, these events, come from the git hooks. So it's like a push happens except I. Didn't do a push. That's the second thing. I want to look at so now that I got that demo.

A

Out of the way you know only took me 15 minutes, so the topic is merge, requests and so topics are one. How does.

A

Data get data from a fork and of in the targets, project of the merge requests and two.

A

How does the merge commits it gets created, and how much is this like a real get push I.

A

Guess I just said what the order is going to be that we're going to look at this. So how does the fork end up in the target project? What happens there is that the moments I created the merge requests. We kicked off an async job somewhere that tries to call a get Li RPC called fetch source fetch source source branch. Let's see if we can find that.

A

A

A

So this is the actual Gately RPC that makes that happen. It fetches on from a source repository and a source branch on to.

C

A

Target ref in the current repository, so the current ripple support the repository would be kid lab or kid lab tests, and this one would be group 3 get lab tests and this one would have been mr1 and I'm not entirely sure what this was. Maybe this was refs had master or no, it's not mastered that would have been emerged. I think it goes into a temporary, a special temporary ref on the repo.

A

Let's see if we can pull that up for moments and it's from modes I think it's public, so I can just type this 3000k slap or get lab tests took kids and I want to see. Merge, requests, okay, crap.

A

Yeah, so that's got the murse requests and I expect it to be one of these. Let's see what our commit ID was. That was something see 59 4 there we go so this would have been merged requests 9 head, so this is this is what happens behind the scene and something called this: do we want to trace back what called this or do we want to look at what this RPC does?

A

I think just what it does? Okay, so yeah? What? How does this work, because that's kind of unexpected if you've never seen this stuff before? Let's see this is a Phet source parent request. This goes from ticket Lee client of Cole yeah. Let's just look at the get Lee code. Next I will have to come back to this later because there are some interesting things here: pet stores branch. So that would be what I do so.

A

I know that these things- okay, so this tells me with the name of the RPC- is in underscore case whatever they call that and I know that the RPC name in the go code is camel not camel case. It's just upper upper case, so I would for fetch source branch without the underscores. This is a mental translation. You have to do all the time if you want to look on the Gately side and then jump over to the real side or back because the calling convention is different and Gigi is my kid.

A

Crap shortcut and I was restricted to the internal directory, because if you do a good crap or the full repo you get defender directory and the vendor director is full of boilerplate code. That makes no sense now, with this I get a targeted results. Oh this is test codes, so we can ignore that, and this is the actual definition and it's suspiciously shorts, and that's because this is just forwarding the request to get Li. Ruby um have I talked about it.

A

Lately, ruby in these videos before I, so goodly Ruby, is a sidecar of the main Catelli process, which is just another gar PC server setting amends the server site of the Gately protocol, but it only implements the subsets that for legacy or other reasons, is in Ruby instead of Ingo. All this does. Is it propagates? The request to Ruby and it will copies the response back, so this is a empty implementation.

A

So now I need to use this underscore thing again to find the Ruby implementation and I do another trick, a search in the Ruby subdirectory, because that can target City bits and then we find the T RPC server the the handler for this RPC on the Ruby sides. So what are we doing here?

A

We have a request, objects and we are backing it here. We're getting out the source repository interesting with leeway to do with the call here and we're getting the repository that we're operating on to the Cir posturing, we're fetching data into, and then we call this methods further down in Gately ruby, which returns some sort of results. So let's look what that method is doing and I'm going to just use my search result here and there's a fetch source branch bang here. So that's probably what we're doing? Oh.

A

And we more indirection, you said really the right methods, I thought we.

A

Again, yeah repository source branch, ref- okay, yes, that's to one local ref. Okay, that goes into another methods which amusingly not actually I, think it actually used I'm, not sure if they're still uses Rockets. So the fact that is this called record underscore fetch source branch. It's just a leftover of the migration projects.

A

This uses something called with repo branch commits and then that deals the commits or it does not use the commits. Why is there an if here? Well there's this source branch? This might be an invalid branch like the branch might have just gotten deleted. It might not exist at all. If that's the case, then we get an ill object here and we end up in this else branch. But if the comment was found, then this thing is updating the local ref to the commit ID. So that seems straightforward enough.

A

So the local ref was this thing, so refs merge, requests nine heads and that's God's, updated to the commit ID that this branch points to in the other rep in the dark in the source. Repository question is: what is this thing? Are you still with me so far, yeah, okay, so with repo branch commits I'm just going to use the search function of my editor and that they starts process or even start branch name, and this instant stenchy AIT's a remote repository if necessary, unless it already is a remote repository, it does check.

A

If the start repository is the same repository, then it loses a commit look up in the same repository, so you can actually call fetch source branch on a branch that was already in the repo and otherwise we call we look up the breath the commit ID on that other repository and we yield that.

A

So, where do we get the?

A

Where do we get that commit from? So we need to look at what this remote repository thing is.

A

Let's look for that in the Ruby directory and we're.

A

A

Think I remember that this is no yeah. This is the remote repository class, and so what we're actually dealing with is a class that gets subclass because we're actually dealing with this subclass.

A

As you can see, this one is the subclass Gately remote repository is a subclass of remote repository, but to understand, what's going on, you actually need to know, look at both files because they interact with each other. This is maybe not necessary anymore. This is again some technical debt from the migration projects, because during the migration projects, we were not always interacting with this one and we had an alternative implementation of this one. Actually, this is the alternative implementation, so.

A

Yeah, you have to read, read both of them, but so what this thing is doing is it's actually making goodly requests here? You can see that we instantiate, essentially it stubs, so it isn't just the check of a branch exists. This looks in the commit servers to see if we can look up a commits. Actually, so that's yeah, it's a fine, commit RPC and then so that this preparatory work and then the final transfer of gets data. Okay. Now we need to go back to the repository RB.

A

So one I should have prepared this better too. This is so complicated that me explaining it to. You is justified.

A

Let's go back to with repo branch commits, so this guy gets the commit ID and then.

A

Okay, it yields start commit ID right, so this is even more complex. So remember this. This thing is: was the the meat of the body that actually fetches the branch? So what are the cases here so there's the case.

A

Start repository so there's the source repository this target repository, that's what we handle there so here we know that source repository is different from the target repository, but it can still happen here that commits ID of branch in source repository already exists in target repository, and in that case we don't we'll get data transfer, because all we needed to know is the commit ID of the other guys branch.

A

But if we reach this else, then commit ID of source branch is foreign to the target repository. So we need to fetch. This is where the final fetch happens, and that goes into another method. That's is with repo something-something.

A

So let's write down here so here we can see the magic happening. The real magic is this fetch ref call, and that makes sure that we get the commits in sight on on something on the refs TMP and that ref then gets deleted. So what does that look like now?

A

Okay, let's, let's just follow the path a bit now let me start and writing down what the hell is going on here, because it's easy to lose track, so something in get lab in get lab, see once to fetch Group three get lab tests so that branch mr1 off in to get lab work get lab tests.

A

That's something calls fetch source branch with arguments. The repo in for the target is get lab or get lab tests source repo. As that.

A

That's wrong way around: this is the target repo.

A

Source repo is group, 3 kilo tests and a source branch is mr1 and.

A

The target ref is reps.

A

Merge requests heads, wait, 9 head. It was something like that.

A

So we've seen that parts, then fetch source branch is implemented in Italy Ruby. So now we're looking at what goes on in Italy Ruby, Gately Ruby uses get lab kits repository.

A

Fetch source branch and then that methods, source branch.

A

Looks up commits ID does some work to avoid data transfer, because if we already have the commit ID, then we don't need to do a data transfer if transfer is needed and up in this guy.

A

With repo team it and then what does that one do.

A

Yeah go ahead, thought.

C

I was going to sew this head, commit that we actually want to create that's. Why do we need it? This.

A

C

Yeah that one we.

A

Need that, because, ultimately, the goal is that somebody clicks the merge button, can we get a merge, commits and merge commits? Is it's just a normal kid commit? It can only reference, but.

C

Why do we need it when we create the merge request, ready.

A

That early already, you mean I I'm, not sure I think it's maybe so we can generate the diffs faster or you know, I, don't have a good answer, I think you're on the creating Bob. So maybe you you would know I, don't know if it always worked like that, but in the current design we fetch it eagerly.

A

It might also be because I think we try to keep some sort of records of.

A

I think a fork completely goes away. We want to keep the commits in the state because bigger they were before they got merged. I. Think.

C

This is because I think that this thing is actually quite recent, because I thought that we didn't do that until we merged the merchants list. I.

A

C

A

Think at the time of the Gateway migration project, when we were dealing with these are pcs. It was already the case that such source branch was called independently of creating the actual merger. Comets. So I, don't know the exact timing, but the idea that the fetching is separate from trading the merge commits is has been it that way for at least two years now: I guess for yeah, one or a year and a half or more okay.

A

Thanks for the question, so we're trying to figure out where this data transfer happens. So then we're in this repository with repo TMP commit- and this thing will fetch on two graphs, TMP.

A

From temper F yield commit to caller delete the temporary reference, and so the caller of this thing then decides to create reference. That's points to the commits, and that way we've remember where the commit is, but we have the freedom to back out and forget that this commit existed and then it will eventually get garbage collected.

A

Now. How does the fetch happen?

A

So the fetch is actually a git fetch that fetches from what looks like an ssh URL but uses a custom, get leak transports to fetch from another Gately server. So this is the part I wanted to get to. So when the data transfer happens because essentially the fetch is it fetch, so that would be that is a fake, fake URL and then it's fetches RF from their remote site.

A

So that would be our rafts, that's Mr Wong, and we want to fetch that onto this not super sure this is correct, get fetch syntax, but this is the general idea of what we're trying with what we're doing. So, how does that get fetch from Italy internal work.

A

So that uses uses a custom SSH transports which is really using the SSH uploads back RPC. So from the point of view, how should I okay get? Ssh is from the point of view of kids. It starts remote as a command on the server and then it talks that commands.

A

But if you look at the way the client works, it just talks to two pipes on a so process that there's a standard in understand it out where it's sending data and the intended use is that that goes into an SSH client and then that goes across an ssh transport to a server then in to get upload back, but it doesn't actually know or care if you're really running SSH, and there is a overwrite mechanism in gates called kids SSH commands.

A

And if you set that on your gate, if you set that environment variable before you run, git, clone or git fetch, then, instead of trying to connect to the other end with SSH gates, will just run that command and assume that it establishes a session for you, and that is how we got this working, so we're using a normal gait fetch command and we're so we're using native kids to do this fetch, but the underlying transports is actually a native of quitly RPC. So what happens at this point is so we use this.

A

Let me just finish my note here: use to spawn custom, necess H transports and then fetch data from the gotelli server that hosts the source repository and that opens up another kind of worms, because how do we know where that Keithley server is.

A

How does this giggly Ruby process know where some other Gately servers on the network? It knows this because all the way at the starts up here, we send along metadata with the.

A

Network address and authentication token of the Catelli server that hosts the source repository.

A

The metadata has handed all the way down so that, when we're down here in Catelli ruby, we can actually make RPC calls to some other Gately server and look at the source repository, and actually we already use this metadata in here when we did the lookup of the commit ID and doing some work to avoid the kid transfer, because before we do that, we checked as the order repository if it exists, is it empty?

A

What is the commit ID do I have to commit ID, then I don't need to fetch it. All that stuff makes calls makes that workhorse. So we're actually looking at to get early clients here quickly. Ruby itself is a client, and that is the code. I was showing you earlier. That was the giggly remote repository class. Where did I throw that?

A

That is this one? This.

A

Class quickly, remote repository is a G RPC clients, that's making calls to somewhere else and for the final actual, get data transfer we're not using we're using a separate executable that acts as a G RPC clients.

A

So, somewhere down here, we have three quests. Let's see, where does this data come from.

A

We're just a token come from it's funny that we have a type of here, but at least were consistent.

A

That comes from pontal no I just come from there with a storage name here.

A

Get the network from.

A

A

Okay, this thing creates a client from the coal objects.

A

Why can't I? Let you to space there.

A

Us, of course, it is.

A

So this thing is decoding the metadata of whether you are the Catholic servers: okay, I'm, not sure if I need.

B

A

Be showing you this because this part works it's there. The important thing to remember is that this happens and it might be nice. If we, let's see, can we log okay I, do want to look at this because I want to log for you what this looks like, but it's the nicest way to do that. I think the nicest way to do that is on the clients. Let's go back to the clients that would be here.

A

That's North Branch that goes in to get the client of Cole.

A

Get loose yes, this one: okay, so that'sthat's metadata! Let's see modulator merge.

A

Let's lock the metadata here, methought inspects, let's see if that works, so I was saying this transfer happens every time, I create a new commits, oh, and to make it easier to see. Let's put some new lines around it. I.

A

Expect this will show up on the left now and let's trigger another transfer, so for that I need to go back to my branch on group 3 projects. But this worked great I think we're going to spend the entire session just talking about this transport stuff and.

B

A

Even about creating the merge commit.

A

So the logging is working, you can see a get, Li call happening. Let's look for a moment what this is so here you can see that we use that authentication did so. This is not an intricately call, yet this is just a normal call, but the authorization gets bastard in the metadata and some stuff where we identify ourselves as the rails. App, we get a correlation ID.

A

Okay: let's go to this branch.

A

And look at the files.

A

Create a new comment on this branch and because this branch is attached to a merge request, I expect that to get fetched into the merge requests automatically at which point we'll see the metadata that flies around to enable that so, let's just edit the changelog again, you.

A

A

It's just aggressive enough: let's put some exclamation marks on there.

A

Let's see what happens now,.

A

So every grisly call is now dumping this in the in the log.

A

Just maybe a bit much, let's see if I can find I hope we can find the one yes I, just also think I think I saw something where the thing was bigger. Yes, here we go so this is where we're doing fetch source branch and let's look at the metadata, so we have two normal authentic author authentication token some stuff about the client name. This is what we care about. Let's split out the rests.

A

So looks like this is base64 encoded. Well, listen dupe, I'm! Guessing this base64. It's not like I. Look at this and I say yes, this is very 64, but I would have used base64. Let's see now, I can do this a fancy way. I can say base64 decode.

A

Why doesn't that work.

A

Okay, that doesn't work, let's just copy this, try that again.

A

Yes, there we go, it was for now. Let's look in here. This is a hash and what does it say? There's something called default and it has this address, and apparently it does not have a token that's interesting. What is this thing?

A

I'm, not sure why we're sending that thing- and this is not sending a token but I hope this is not a security bug- I'm, pretty sure it's not, but this is yeah and let's copy this back here and just overwrite this, because it's clear so in the case of the fetch source branch RPC we're sending along this extra metadata back to the giftee server, the Grizzly server passes it along to quickly Ruby and then getting a ruby unpacks.

A

It's and Gately Ruby uses this data to make T RPC calls to the key server that hosts the source repository, so yeah I guess correct. We go. This is the topic of today's meeting, and this is the thing I want to I want to explain is that this carrying around of this metadata is happening like this.

A

Any questions so far is.

B

The do you think the tokens not there, because this is using a domain socket, and so it's on the same machine is still like a different security scheme. That's.

A

Let's see why what a token is not there a good question, so you open a new window. The contact file in GDK that, just like italy, is at the top level of GDK. There is a Catelli directory and there's a conflict tomo. So let's see what the settings are over here. This looks like it's commented outs.

A

If I look for the word token, so the answer is there is no token, so this null here is correct and what this little odds is that here we're setting a bearer token anyway, because what is that bearer token now I guess to answer that question? We should look at how that bearer token gets generated.

A

So that's based on this, and what do we do here? Token storage, 2's. So I wonder if this is maybe the empty string, because if we take the empty string here and we feed that into an H Mac, then you probably still get something.

A

B

A

To our riddle, I think this is returning a null and if we would have a null check here, we could return early and just say there is no token, but instead it's acting as if the token is the empty string and this gets ignored by the server. Because this we just looked at the server config file and there we're not expecting it. Okay,.

B

Cool I had one more question about this custom: ssh transport. So it's not really ssh at all. It's just a transport right, because it's using g RPC as a tunnel.

A

Yeah yeah, that's a very good question. I think that is the last thing we should look at today. So that thing, let's see today, I'm not going to save this file. That is one of the. So one of the reasons I really want to show.

A

This is that you see there are two get any clients in action here that you might not know even exists because they are hidden inside Keithley itself and, like I said, the one is caitli ruby, which is a client that will make calls to any of a guilty server in your kidnap and the other is called get the SSH. So let's go back to a goodly window and let's look under CMD, so there we have get the SSH now this is the other client, and this thing gets. It takes it's a information from environment variables.

A

Let's see if we can illustrate what's going on here by leaking intentionally leaking some data, so I think this cutely underscore stuff is data that we're using and Arg. V is interesting. So what's a good way to log this just wanted sheets.

A

Barton I: don't care about the error open file.

A

Open file works.

A

B

A

Yeah and then I want to write flag, so that will be OS. That's our pens and I'm not sure. If I need money create yeah.

B

Our contributes and.

A

Do this then I, don't so I think that will work we'll know we'll know in a moment and defer have thoughts close and what do I want to log. First of all, I want to log.

A

A

Let's put a new line there and then I want to see the environments and.

A

Weights I want to do it like this they're going to spawn a shell commands.

A

How many type of this one needs? That's my commands, I, say and fourth command start standard out equals F.

A

And then I'm going to run that thing so I think this will let us capture some data and maybe just to be nice. Let's puts.

A

Marker here.

A

Yeah and let's put in lying on there because I wouldn't be surprised. If this thing does not have a note, probably does every training new line, okay, impromptu, improvised logging, I think this will work. Now we need to recompile this executable.

A

Let's see I would do Co path equals current directory. This is some weird shell syntax, because I'm using the plan 9 shell, the co path- is get Li and I want to do. Go. Install off this thing.

A

Cannot use always our pants type int s type, always file modes.

A

Interesting I swapped.

A

Like this, maybe.

B

A

A

Eiling and let's check the time stamp on the file that.

A

Looks like it just got, created cool. So if this works, if I got all of these rights improvising on the spot, then next time I edit this file, it will trigger another fetch, because the branch is attached to a merge request and we'll see some data in that log file.

A

A

A

It took a while before.

A

B

A

I'm not sure if something's happening here.

A

What did did something go wrong into merch requests.

A

And still not there.

A

A

A

Am I looking at the wrong check now.

A

This undoing something wrong here,.

A

A

A

Oh I, clicked ministration and then I click merge, so I need to create a new merch request and we learned the other day. I need to do it. Sorry. The other day we learned how.

C

A

I need to do it here, let's go again and we want to take em r1.

A

A

Why am I not see how it's running okay take to submit please log something.

B

So do you need to create a new commit since you merged it in and they're the same commits now.

A

I'm not sure if this has been fetched into the other repo. Yet if.

C

It was merged before it was wasn't, it I mean.

A

To create a new commit from that branch for those new commits, don't exists in the sea, it's still doing stuff.

A

Now that's God's created.

A

Why is there no data transfer, maybe my.

C

Are you using that Gately that you just.

A

Yeah good question I think I just replaced the Gately ssh executable that that quickly runs. But let's.

A

To go in stock, that's the this should have installed suitable into the right path, but if it's good, if it was getting run, then stuff should be in there now.

C

Is it for me, it's always hard to know which thing that GDK is using so I just yeah then can.

B

You do a search for another version of the giddily SSH binary to see if it lives in a different location, I'm pretty.

A

Sure there are other versions, but let's see I think it uses the.

A

Via the bath via the search path, no this bin dear and that's the one where I just got the new executable.

A

Why doesn't that work.

A

That is Godfrey compiled, so it be using that executable.

A

Well, we're running out of time, so I have to show this later. Is there something I want to show about this, while we're here.

A

Yeah, so this is a separate executable. It's indicate Lee repo, at least, and you may have seen that at the top left of the Keithley repo. There is this subdirectory called client, and that is a gr PC client specifically made for connecting to Catelli. So the Gately SSH executables, you reusing that Co clients and the it's actually reusing a lot of how great lab shell works so because in get lab shell we're doing okay, let's end with that. So if you think back to SSH SSH, so what you have there, you have get.

A

Clients connects with SSH to server remotely runs its upload back and it communicates over standard in and standard out. So in the gate lab case, SSH server runs with nutshell.

A

Claps shell remotely runs, get applauded back via gotelli and get lab shells copying the data back and forth that comes in over over on the ssh session. So it's almost as if we're using the server-side components, we're skipping a couple steps of what happens in get lab shell and get lap shell.

A

You have sh t you have to get lab shell parts and then that is acting as a catalyst lines and copying data back and forth, and we just directly spawn the server-side parts of the kids ssh the way gate ssh is implemented in gait lab. We spawn that directly plug that in to get fetch and because get fetch is in this case running on a Keithley server. It has network access to the other Gately servers and we can get away with this.

A

Yeah, okay, this was fun well, it was I find this fun I.

C

Think what good luck shall exactly do if we run the Italy and whatever wrapper we have that executes directly as a necessary to come I, don't.

A

We don't use git lab shell for that, so we have in Italy. We have library codes that can do.

A

That year, okay I need to explain this better. So you have get lab shell. That speaks G RPC.

C

A

Get any yes Italy and that spawns.

A

It upload back and in front of that you have sshd and that uses pipes.

A

And then in front of that you have message: clients which uses Internet and then in front of that you have get fetch.

A

So that is roughly the chain, and what we do with the internal traffic case is that we have it fetch and that's in.

C

Your own place, the SSH client sshd, and it gets lab so far. Yes,.

A

We explains this part and we go directly to these G RPC points. Gotcha.

C

B

A gr PC Marcus are we using to.

A

Do that so the RPC is called SSH uploads back that's for the the fetched case. The other direction is called SSH received back so yeah. We have good fashion that spawns quickly SSH and that makes an RPC connection to get the wherever quickly, where exactly and that spawns its uploads back and of course, here we have Italy ruby, which spawns that thing and we have Italy.

A

Erp C on internal UNIX sockets with that. Are you this yet in.

C

Front of that then we have the actual. Yes.

A

Yes, exactly so, you have good lab C full circle. Yes,.

C

A

Github C makes G RPC call to get Li and we have this crazy path and and the magic is that this skittle II. So this is on server' 1.soak, italy 1, and this is Keithley.

A

B

By giving one you mean the Reuben, you mean the s sh x, no.

A

No I mean that these might be different machines at different Network addresses what yeah that's right, because in the general case on Caitlyn comb, the fork might be on a completely different skill, a server, and it's also worth noting. That's sorry for that noise. It's worth noting that the way we designed this, even in GDK, where there is no goodly one and there's only one gotelli process as long as the source you're going across a fork. It already makes a network connection.

A

We intentionally design it like that, so that this whole network stuff gets exercised more because if it's a mechanism that only kicks in, we have to quickly servers- and you can have bugs that you don't find out about unless you have to get Li servers and it already kicks in with one Gately server. So that thing is then actually making a connection to itself and it that has to be authenticated. So it gets the authentication all the way back from catalepsy.

B

For authenticates to itself, yes, exactly.

A

Because it it's an external connection, it's coming in again.

A

Yeah Wow, we didn't even talk about merge, commits but yeah we're I think we're well we're over one hour now, so we should leave it at this. For this time or any last questions you know. Okay, then, let's see if I can successfully without bumbling turn off the recording.

A

Stop recording bye.