## Introduction

The AzerothCore bash dashboard is a collection of scripts that help with the installation and maintenance of an AzerothCore server.
It allows to easily install, update and execute AzerothCore on your machine in a tremendously small amount of steps.

Installing a development or production private server has never been so easy before. 
If you need any help just [ask a question](https://www.azerothcore.org/wiki/How-to-ask-for-help).


## Requirements

You need to have [git](https://git-scm.com/), [curl](https://curl.se/), [unzip](https://github.com/madler/unzip), [sudo](https://www.sudo.ws/) installed in your machine. 
No other software is required to be installed manually.


- debian/ubuntu-based: `apt update && apt install git curl unzip sudo`
- macOS: `brew install git`
- Windows: download and install [Git for Windows](https://gitforwindows.org/)

### Notes
- For macOS users: install and use the latest version of bash to run the commands of the dashboard (`brew install bash`)
- For Windows users: the commands need to be executed within the "git bash" shell or a bash-compatible shell such as WSL, cygwin etc..
  However, git bash is suggested because is preinstalled with git for windows (one of our requirements)
  

## Setup

### Get the AC sources

```
git clone https://github.com/azerothcore/azerothcore-wotlk.git; cd azerothcore-wotlk
```

### Configuration

There is a [conf/dist/config.sh](https://github.com/azerothcore/azerothcore-wotlk/blob/master/conf/dist/config.sh) 
file containing a default configuration. Have a look at it. 
Most of the configuration defaults will probably work for your case, 
but you can copy it under `conf/config.sh` and change values as you please.


### Install all AC dependencies

```
./acore.sh install-deps
```

NOTE: on Windows it must be executed as an administrator

### Build everything from scratch

```
./acore.sh compiler all
```

### Set-up the database

- Either connect to your MySQL database (with `sudo mysql -u root`) and manually create the `acore` MySQL user by running:

```
DROP USER IF EXISTS 'acore'@'localhost';
DROP USER IF EXISTS 'acore'@'127.0.0.1';
CREATE USER 'acore'@'localhost' IDENTIFIED BY 'acore';
CREATE USER 'acore'@'127.0.0.1' IDENTIFIED BY 'acore';
GRANT ALL PRIVILEGES ON * . * TO 'acore'@'localhost' WITH GRANT OPTION;
GRANT ALL PRIVILEGES ON * . * TO 'acore'@'127.0.0.1' WITH GRANT OPTION;
FLUSH PRIVILEGES;
exit;
```

*Note:  even though the `acore` user is only accessible from localhost, 
it is a good practice to change its password to something more secure.*

### Download the latest client data

Get the latest client data:

```
./acore.sh client-data
```

### Server config files

create these 2 files. They contain the default configuration for the worldserver and authserver, if you don't wish to modify simply copying them is enough.

#### Linux and Mac

```
cp env/dist/etc/authserver.conf.dist env/dist/etc/authserver.conf
cp env/dist/etc/worldserver.conf.dist env/dist/etc/worldserver.conf
```

#### Windows and Mac

```
cp env/dist/configs/authserver.conf.dist env/dist/configs/authserver.conf
cp env/dist/configs/worldserver.conf.dist env/dist/configs/worldserver.conf
```

### Result

If you followed the above, you'll get your server inside the `env/dist` directory.

The `worldserver` and `authserver` binaries are located in `azerothcore-wotlk/env/dist/bin`.

You can either run them directly or use the restarter (see below).
The first startup of the `worldserver` will install a full AzerothCore Database. No need to import any DB update at this point.

### Restarter

The AzerothCore dashboard comes with a bundled restarter suite:

```
./acore.sh run-worldserver
```

Wait until the process is completed then run: 

```
./acore.sh run-authserver
```

For dedicated servers, 
you may want to run them inside terminal multiplexer sessions using tools like `tmux` (see below).


## How to update your server

Update the sources:

```
git pull
```

Rebuild:
```
./acore.sh compiler build
```

Update the database:

[https://www.azerothcore.org/wiki/database-keeping-the-server-up-to-date](https://www.azerothcore.org/wiki/database-keeping-the-server-up-to-date)

That's it.


## Tips for dedicated (production) servers

### Daily backups of your databases via Telegram

Getting daily backups of your private server databases directly to your phone/computer 
via [Telegram](https://telegram.org/) messages?

Yes, that's possible. Just use: [azerothcore/telegram-automated-db-backup](https://github.com/azerothcore/telegram-automated-db-backup)

### Visual Studio Code SSH

You can easily install AzerothCore in a linux server without any kind of GUI,
simply connecting remotely via ssh using [Visual Studio Code](https://code.visualstudio.com/)
and the [SSH](https://code.visualstudio.com/docs/remote/ssh)
and the [SSH: Editing Configuration Files](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-ssh-edit) extensions so you'll feel just like at home.

### Run AzerothCore inside Tmux sessions

You can use [tmux](https://github.com/tmux/tmux) as terminal multiplexer, 
it will allow you to easily manage your processes inside a server with no GUI.

You can create 2 sessions and run the `worldserver` and `authserver` processes inside them:

- `tmux new -s world-session`
- now run the `./acore.sh run-worldserver` inside it, then detach from it


- `tmux new -s auth-session`
- now run the `./acore.sh run-authserver` inside it, then detach from it

You can detach using `CTRL+B+D` to exit the session without killing the process.
If connected using VSCode SSH, you can just close the terminal session.

You can attach again to the `world-session` session using:

- `tmux attach -t world-session`

Other useful commands:

- create a new session: `tmux new -s my_session`
- list all sessions: `tmux ls`
- kill a session: `tmux kill my_session` (or just attach to it and type `exit`)
- kill ALL sessions: `tmux kill-server`
- ...more details available at the [tmux wiki](https://github.com/tmux/tmux/wiki)


### Automatically start the tmux sessions at system startup

You can automatically create the tmux sessions and execute the `authserver` and `worldserver` using this simple script:

```sh
#!/usr/bin/env bash

<!DOCTYPE markdown>
# CHANGE THESE WITH THE CORRECT PATHS
authserver="/path/to/azerothcore-wotlk/acore.sh run-authserver"
worldserver="/path/to/azerothcore-wotlk/acore.sh run-worldserver"

authserver_session="auth-session"
worldserver_session="world-session"

if tmux new-session -d -s $authserver_session; then
    echo "Created authserver session: $authserver_session"
else
    echo "Error when trying to create authserver session: $authserver_session"
fi

if tmux new-session -d -s $worldserver_session; then
    echo "Created worldserver session: $worldserver_session"
else
    echo "Error when trying to create worldserver session: $worldserver_session"
fi

if tmux send-keys -t $authserver_session "$authserver" C-m; then
    echo "Executed \"$authserver\" inside $authserver_session"
    echo "You can attach to $authserver_session and check the result using \"tmux attach -t $authserver_session\""
else
    echo "Error when executing \"$authserver\" inside $authserver_session"
fi

if tmux send-keys -t $worldserver_session "$worldserver" C-m; then
    echo "Executed \"$worldserver\" inside $worldserver_session"
    echo "You can attach to $worldserver_session and check the result using \"tmux attach -t $worldserver_session\""
else
    echo "Error when executing \"$worldserver\" inside $worldserver_session"
fi
```

On unix systems, you can then use [crontab](https://en.wikipedia.org/wiki/Cron) 
to run the script automatically at system startup:

```
crontab -e
```

then add this line (replace `/path/to/startup.sh` with the path of where you placed the above script):

```
@reboot /bin/bash /path/to/startup.sh
```