
## CAUTION: This is not an ideal path I would use in Production. I would need to think very strongly before using it in Development too. 

I am posting with the intention that it helps bring together some of the info and it does help someone in a pinch, or maybe even to work out a long-term solution.

There are a few tickets and posts out there noting that you can't run Wordpress Multisite on a non-standard port (80 or 443).

[https://core.trac.wordpress.org/ticket/21077](https://core.trac.wordpress.org/ticket/21077)

[https://core.trac.wordpress.org/ticket/42993](https://core.trac.wordpress.org/ticket/42993)

[https://wordpress.stackexchange.com/questions/212978/multisite-network-port-num-issues](https://wordpress.stackexchange.com/questions/212978/multisite-network-port-num-issues)


That said, here are my notes/steps towards adjusting it to get it working. It is completely outside the realm of what I would do in Production, but for testing in development where I can't use port 80, it works.


## Initial setup
1) Clone the [docker-compose repo](https://github.com/levijackson/docker-wordpress)
2) Set up Wordpress [http://localhost:8000](http://localhost:8000)
3) Enable Multisite in `wp-config.php`
```
define( 'WP_ALLOW_MULTISITE', true );
```
4) Edit `/etc/hosts` and add a few entries for the sites you want to configure
```
172.99.0.9     wordpress1.localhost
172.99.0.9     wordpress2.localhost
```

## Adjustments
If you go to `Tools` => `Network Setup` now, you'll see 
```
Error: You cannot install a network of sites with your server address.`
You cannot use port numbers such as :8000.
```

### Code changes
1) Edit `wp-admin/includes/network.php` to add the port you configured Docker to use, `8000` in my case.
```
# function network_step1 

if ( ( false !== $has_ports && ! in_array( $has_ports, array( ':80', ':443', ':8000' ), true ) ) ) {
```

2) Go to `Tools` => `Network Setup` and [run through step 3](https://wordpress.org/support/article/create-a-network/#step-3-installing-a-network). You'll end up on a page that looks like this
![Setup messages](/images/posts/wordpress-multi-site-network/wordpress_multisite_settings.png)


3) Follow the instructions and adjust `wp-config.php` and `.htaccess`

4) At this stage you need to log back into admin. If you try, it won't work. The cookies that are set during the login process don't strip out the port from the host name used with the cookie. 
You'll need to edit another spot to strip out the port when it assigns the cookie.
```
# wp-includes/ms-default-constants.php

define( 'COOKIE_DOMAIN', '.' . $current_network->cookie_domain );

=>

define( 'COOKIE_DOMAIN', '.' . str_replace(':8000', '', $current_network->cookie_domain ));
```

### Database changes
1) Add a new site
`My Sites` => `Network Admin` => `Sites`
![New site fields](/images/posts/wordpress-multi-site-network/new_site_fields.png)

2) It adds the site and strips out the port, so you'll need to log in and adjust the URL in the database directly.

```
# In wp_2_options (each site will have a table of their own)
- Adjust the `option_name` with the values of `siteurl` and `home`
http://wordpress1.localhost8000
=> 
http://wordpress1.localhost:8000
```

3) Make the same adjustment in `wp_blogs` for the site

4) You'll now be able to load the site from [http://wordpress1.localhost:8000/](http://wordpress1.localhost:8000/)



## Now what?
That is a lot of manual work to make it work well in development. If I needed this to work on a custom port I would look to see if I could work out a way to do it with a plugin. The path I went down in this post will not allow for updating Wordpress easily.


### Alternatives to Multisite
If I was looking to setup a true multisite environment, I would lean more strongly towards seeing if using `wp-config.php` as suggested in [this ticket](https://core.trac.wordpress.org/ticket/15467#comment:1) is a viable option.

Multisite is powerful, but it also has some big pieces that make it harder to pick as an option for hosting many web sites with it.
- A combined `wp_users` table means all users funnel into one spot. It makes it tricker to segment client data and spin up test environments with "just enough" data.
- The nomenclature still references them as `blogs`. It's minor, but it does feel symbolic that the Multisite system has lagged behind with regard to dispelling the feeling that Wordpress is more than just a blog platform.




Setting up Wordpress Multisite using Docker and a custom port

Lately I've been finding myself experimenting with Wordpress. I created a <a href="https://github.com/levijackson/docker-wordpress" target="_blank">docker-compose file</a> to help me stand up a new clean setup more quickly.

It is based upon the <a href="https://docs.docker.com/compose/wordpress/" target="_blank">Docker compose guide</a>, but includes some extras, like phpMyAdmin.

## Usage
1) Clone the repository or copy the docker-compose file
2) Start the container `docker-compose up -d`
3) Run through the Wordpress installer http://localhost:8000

## Adding a theme or plugin
The `wp-content/` directory is mounted to the local file system. It makes it easy to copy plugins, or edit the theme files from your IDE.

## phpMyAdmin
You can access phpMyAdmin from http://localhost:8080 using the credentials set in the `docker-compose.yml` file (`MYSQL_USER` and `MYSQL_PASSWORD`).

## Reset the database
If you find you need to reset the data, you can delete the volumes created.
```
docker-compose down --volumes
```

Develop Wordpress using Docker

The <a href="https://docs.aws.amazon.com/cli/latest/userguide/install-macos.html" target="_blank" rel="noopener noreferrer">AWS guide</a> is still a good starting point for this. The main piece I had trouble with was using `aws --version` once it was installed.

*Prerequisite:* have Python3 and Pip3 installed

## Quick answer:
Adjust $PATH so it has the path to the AWS executable.


## Longer answer:
### 1) Find where it installed AWS

The guide says to use `which python3` - but when I installed Python it installed it to my user, not the system. 

When you run `pip3 install awscli --updgrade --user` it should spit out something like this
```
... awscli in ./Library/Python/3.8/lib/python/site-packages (1.18.18)
```
The **"./"** indicated it is a local path, NOT the system path. You can confirm by checking 
```
ls -la /Users/<insert_user_name>/Library/Python/3.8/bin/aws
```

### 2) Edit `~./bash_profile` and add the path
```
export PATH=/Users/<insert_user_name>/Library/Python/3.8/bin:$PATH
```

### 3) Reload the profile
```
source .bash_profile
```
### 4) Test - `aws --version`. It should output
```
aws-cli/1.18.18 Python/3.8.2 Darwin/17.7.0 botocore/1.15.18
```

Installing AWS CLI on Mac

Setting up composer to use a private repo is pretty easy... after you've done it once. There are a few things that can trip you up, such as the naming of the package and the version to include. The <a href="https://getcomposer.org/doc/05-repositories.md#using-private-repositories" target="_blank" rel="noopener noreferrer">docs</a> for getting the configuration set up got me about 95% of the way there.

This guide assumes you already have a *composer.json* file created, and you're looking to add a new private repository to that.


## Part 1: Bitbucket configuration
Composer is going to need access to your Bitbucket account in order to fetch the private git repo. An OAuth consumer can be used to give composer access.
1) In Bitbucket, go to your "Bitbucket Settings" page `https://bitbucket.org/account/user/<username>/`

2) Click "OAuth"

![Click OAuth](/images/posts/using-a-private-repo-with-composer-and-bitbucket/oauth_link.png)

3) Click the "Add consumer" button

![Click the "Add consumer" button](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_button.png)


4) Fill in the name, description, callback URL (this can be anything - composer won't use it but it is required by Bitbucket), select This is a private consumer, and select Repositories: Read for the permissions.

![Consumer config part 1](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_config_pt1.png)

![Consumer config part 2](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_config_pt2.png)


## Part 2: Composer configuration
Using the *Key* and *Secret* from the OAuth consumer you created in part 1, you will need to add an *auth.json* file in composer's home directory.
```
vi ~/.composer/auth.json
```
```
{
 "bitbucket-oauth": {
 "bitbucket.org": {
 "consumer-key": "myKey",
 "consumer-secret": "mySecret"
 }
 }
}
```

## Part 3: Configure composer.json
1) Add your private repository to the configuration so composer can look there for packages. The URL for the repo can be found in Bitbucket by clicking the "Clone" button in the top right of the repository view.

![Package URL](/images/posts/using-a-private-repo-with-composer-and-bitbucket/package_url.png)

```
"repositories": [
 {
 "type": "git",
 "url": "https://aerosox@bitbucket.org/aerosox/dataconverter.git"
 }
]
```

2) Require the package in *composer.json*. With either of these methods.
- CLI: `composer require aerosox/dataconverter`
- Edit `composer.json`

```
"require": {
 "aerosox/dataconverter": "master@dev"
 }
```

## Troubleshooting
1) the package name in the *require* matches the name from the `composer.json` configuration for the package you are including.

```
// composer.json from aerosox/dataconvert

{
 // even though the git repo is configured as aerosox/dataconverter.git, this name *could* be anything. This is what composer is going to be looking for when it searches for the package to install.
 "name": "aerosox/dataconverter",
 "description": "Convert data formats",
 "type": "library",
 "authors": [
 {
 "name": "Levi Jackson",
 "email": "aerosox@gmail.com"
 }
 ],
 "autoload": {
 "psr-4": {
 "DataConverter\\": "src/"
 }
 },
 "require-dev": {
 "phpunit/phpunit": "^6.5"
 }
}
```
2) I saw a lot of guides say to load the package as `"aerosox/dataconverter": "master-dev"`. I initially thought that *master-dev* was a composer standard, but it's not. If you want to use that, you'd want to set up an alias in the package so it can be found.

```
"extra": {
 "branch-alias": {
 "master-dev": "actual-branch-name"
 }
}
```

Using a private repo with composer and bitbucket

I was discussing the speed of filtering an array with a colleague and I had been under the assumption that using PHP *array_*\* functions are considerably faster than using a loop (foreach, for, while) . I could not find evidence of that when I was doing some Google searches though so I decided to do a little bit of a speed test on my own.

For all of these tests I set up the following beforehand:

```
ini_set('memory_limit', '500M');
$data = range(0, 1000000);
```

## Test 1: array_filter vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.37 |
| while | 0.58 |
| for | 0.61 |
| array_filter | 0.74 |


```
// array_filter loop average 0.74 seconds
$start = microtime(true);
$data = array_filter($data, function ($item) {
 return $item%2;
});
$end = microtime(true);

echo $end - $start;

// Foreach loop average 0.37 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
 if ($item%2) {
 $newData[] = $item;
 }
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.61 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
 if ($data[$i]%2) {
 $newData[] = $data[$i];
 }
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.58 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
 if ($data[$i]%2) {
 $newData[] = $data[$i];
 }
 $i++;
}
$end = microtime(true);

echo $end - $start;
```


## Test 2: array_map vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.65 |
| while | 0.69 |
| for | 0.76 |
| array_filter | 1.38 |

```
// array_map average 1.38 seconds
$start = microtime(true);
$data = array_map(function ($item) {
 return $item+1;
}, $data);
$end = microtime(true);

echo $end - $start;

// For loop average 0.65 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
 $newData[] = $item+1;
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.76 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
 $newData[] = $data[$i]+1;
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.69 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
 $newData[] = $data[$i];
 $i++;
}
$end = microtime(true);

echo $end - $start;
```

## Test 3: array_walk vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.65 |
| while | 0.69 |
| for | 0.72 |
| array_filter | 0.76 |

```
// array_walk average 0.72 seconds
$start = microtime(true);
$data = array_walk($data, function ($item) {
 return $item+1;
});
$end = microtime(true);

echo $end - $start;

// Foreach loop average 0.65 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
 $newData[] = $item+1;
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.76 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
 $newData[] = $data[$i]+1;
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.69 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
 $newData[] = $data[$i];
 $i++;
}
$end = microtime(true);

echo $end - $start;
```

## End Notes
I was incorrect when I thought that *array_\** functions are faster! Albeit the speed difference is pretty negligible when talking about using it once or twice during page execution. I won't stop using the *array_\** functions because of my findings, they still offer a cleaner way of writing the code. I will only second guess using them when I am writing code that has the potential to be processed thousands of times.

*I tested these with a pretty basic data set. Speed may vary depending on the type of data being used as well as the version of PHP (I used 5.5.4).*

Hello there!