Here's a bash script for running a lot of separate git commits.



Don't you feel like a 10th level terminal mage whenever you get any sort of bash script to run?  Bash is nice because it'll usually just work in the terminal. You don't need another runtime to get it to work. But wow, is it not a skill that I use often, and it has sharp edges I get myself caught on every time.

In this example, I had a monorepo that relies on conventional commit using commitlint to generate change logs. Thus, changes for every package had to be committed separately. 

First, I made [changes over multiple files](/post/search-replace-multiple-files-macos) using a method similar to one I've written about before.

Then, I made and ran this script:

```bash
for FILE in $(git diff --name-only); do
  PACKAGE=`echo $FILE | sed "s|packages/$.*$/src.*|\1|"`
  git add "packages/$PACKAGE"
  git commit -m "refactor($PACKAGE): message about the thing done to all packages"
done
```

So, what's here?

- The for loop should look pretty familiar. Be careful to include that semicolon. The body can be multi-line, no problem.
- The thing being looped over is a list of files that have changed. Using the `--name-only` flag, only the file names are listed, not the other instructional text from git.
- `PACKAGE` is being defined here as another variable. Don't try to put spaces around that assignment operator. 
- The backticks for the command in the variable declaration are one way of surrounding a command. The dollar parenthesis in the for loop is another.
- When you use a variable previously declared and want the value of it, you prepend the dollar sign, as in `$FILE`.
- In the `sed` command, I'm using `|` pipes instead of the traditional forward slash. `sed` doesn't care what you use for delimiters, and in this case pipes require fewer escapes on the forward slashes in the pattern.
- The parenthesis in the pattern have to be escaped. This is odd, since this is the standard syntax for capture groups. Later, `\1` represents the group.
- And did you know that a `git commit` can have 2 messages?  One for the subject line: `-m`, and one for the body: `--message`.

Amazing. See, 10th level terminal mage.

A bash script for running a lot of separate git commits.

Automate Separate Commits in Bash

When you run a shell script or some other process from NodeJs and want to get the output in a stream to a client, you can redirect or pipe the output from the process that originally outputs to stdout into your socketio stream.  



First, setup socketio on your server as you normally would:

```js
var io = require('socket.io').listen(80);
```

    io.sockets.on('connection', function (socket) {
      runMyProcess(socket);
      socket.on('my other event', function (data) {
        console.log(data);
      });
    });

Second, setup your process to run [using spawn](http://rockycode.com/blog/run-shell-script-nodejs/).  For instance:

```js
var spawn = require('child_process').spawn;
var myProcess = spawn('sh', [ 'myShellScript.sh' ]);
```

And setup your `myProcess` variable with the needed callbacks.  The 'data' callback is called whenever there is output from the process.  So, if you want to catch data from `stdout` and `stderr`, catch those and emit the data into your socketio stream, a la:

```js
myProcess.stdout.setEncoding('utf-8');
myProcess.stdout.on('data', function (data) {
  socket.emit('process_data', data);
});
myProcess.stderr.setEncoding('utf-8');
myProcess.stderr.on('data', function (data) {
  socket.emit('process_data', data);
});
```

An important note from [the docs](http://nodejs.org/api/stream.html#stream_event_data) is that:

> The 'data' event emits either a Buffer (by default) or a string if setEncoding() was used.

If I didn't set the encoding so strings were returned, they did not transfer well over socketio.  Well, there you have it.  You can now get output from child processes to stream through socketio.  In my case, I was wanting to show realtime output in a web client.  It's a fun combination of abilities that should produce interesting applications.  Have fun!

When you run a shell script or some other process from NodeJs and want to get the output in a stream to a client, you can redirect or pipe the output from t

Pipe stdout to SocketIO

NodeJs can do many things.  It can even run things that it can't do itself.  For instance, I have a shell script that I don't want to rewrite in Javascript, so I want my Node app to run the shell script.  No problemo.  



(Updated 22 Aug 2016)

The [docs](http://nodejs.org/api/child_process.html) indicate a number of ways you can kick off child processes.  In my case, I wanted to use [`spawn`](http://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options).

Import the `child_process` library:

```js
const { spawn } = require('child_process')
```

Now you have `spawn` available to call.  Just send it the right stuff.  I have a `deploy.sh` script that I want to run.  The command I'll actually run is `sh`, and I'll pass the name of the script to it in the 2nd parameter.  I can also specify other options in the 3rd parameter.  For instance, I want this to execute in a certain directory and with certain commands available to it via the `PATH` variable.  And so:

```js
const deploySh = spawn('sh', [ 'deploy.sh' ], {
  cwd: process.env.HOME + '/myProject',
  env: Object.assign({}, process.env, { PATH: process.env.PATH + ':/usr/local/bin' })
})
```

This will execute the shell script.  There are other callback events that you may/not want to set to grab the data that comes back from the process, such as 'data', 'end', or 'exit'.

Rock that!

Run a Shell Script from NodeJs

Have you ever tried to start up a local dev server and attach it to a port only to find that the port says it's already in use.  Here's a quick way to find those zombies and kill 'em good.



## Server Startup Messages

When you go to start your server, you get your annoying error message that just irks you.  If you're starting a Java server, it looks something like:

```bash
java.net.BindException: Address already in use localhost:8080
```

Or in node:

```bash
Error: listen EADDRINUSE
```

No matter the server, you're trying to start, there's something in your way, and it's going down.

## Finding the Perp

Once you find him, he's toast.  Open your terminal and query the problem port:
  
    > lsof -i tcp:8080

From the man file, lsof is:

> Lsof revision 4.84 lists on its standard output file information about files opened by processes

And the -i is showing you Internet addresses:

> This option selects the listing of files any of whose Internet address matches the  address specified in i.  If no address is specified, this option selects the listing of all Internet and x.25 (HP-UX) network files.

## Kill the process

Running the `lsof` command should return something like:

    COMMAND  PID    USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
    java    7135 jtsnake   46u  IPv4 0xffffff801a349c00      0t0  TCP *:http-alt (LISTEN)


That `PID` is the identifier you were looking for.  Now, run a handy:

```bash
> kill 7135 
```

to put the thing out of its misery.  

Just like a fire in the forest, now a new tree has a place to grow.

Have you ever tried to start up a local dev server and attach it to a port only to find that the port says it's already in use.  Here's a quick way to find

Find and Kill a Process on a Port

django-admin.py is a utility script that is used by django to start projects, etc.  Sometimes, it seems that it's available to me in the terminal.  At other times, it melts away, unavailable.  So, where is it, and how do I make it findable?



django-admin.py is in the your site-packages/django/bin/ directory.  And that brings up another good point.  Where is your site-packages directory specifically?  You can find it with this command:

```bash
python -c "from distutils.sysconfig import get_python_lib; print get_python_lib()"
```

Once you find the site-packages directory, go to the bin/ subdirectory to find the django-admin.py.  You just need to put this in your path so that it's findable from wherever you need to use it.  Here's a possibility:

```bash
cd /usr/local/bin/ &&
sudo ln -s [site-packages]/bin/django-admin.py django-admin.py
```

django-admin.py is a utility script that is used by django to start projects, etc.  Sometimes, it seems that it's available to me in the terminal.  At other