Skip to content
BranchesTags

Repository files navigation

Openfire Docker Container

This will build a vanilla installation of Openfire inside of a Docker container. Because Openfire wants persistent data, I've copied over the vanilla contents of the following directories to be mounted as persistent volumes.

  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins

Building The Container

If you prefer to build the container yourself, you'll need to do some prep work.

  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.

Running The Container

Copy the contents of the run directory to a location on the filesystem from where you run containers. I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.

Via Docker Compose

  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.

Manually

  1. From $rundir, optionally edit the run.sh file to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their appropriate places, start Openfire, and tail the logfile.

Connecting To Openfire

You'll be able to connect by opening a browser and going to http://localhost:9090, optionally replacing localhost with the hostname or IP of your Docker host system.

If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.

As long as you start future iterations of the container from this directory, changes to the configuration, plugins, and the embedded database will be preserved.

Installing SSL Certificates

For ease in installing SSL certificates, see this post.

Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter is provided in case your origin container only provides the JRE.

  1. Connect to the container and start a shell

     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security

In case that post disappears in the future, an abridged version of it is saved here.

Upgrading The Container (minor versions)

When the time comes to upgrade the container, it's quite simple.

  1. Stop and remove the existing container with docker kill and docker rm. All of your data is persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.

Upgrading from Openfire 3 to Openfire 4

Caveats

  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user

Upgrade Steps

  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:
    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means

About

Docker container build/run env for Openfire XMPP server

Resources

Readme
Activity

Stars

6 stars

Watchers

1 watching

Forks

1 fork
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - oskapt/docker-openfire: Docker container build/run env for Openfire XMPP server · GitHub
Skip to content
BranchesTags
Repository files navigation
Openfire Docker Container
This will build a vanilla installation of Openfire
inside of a Docker container. Because Openfire wants persistent data, I've copied over
the vanilla contents of the following directories to be mounted as persistent volumes.
  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins
Building The Container
If you prefer to build the container yourself, you'll need to do some prep work.
  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.
Running The Container
Copy the contents of the run directory to a location on the filesystem from where you run containers.
I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.
Via Docker Compose
  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.
Manually
  1. From $rundir, optionally edit the run.sh file to change the tag for the
container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their
appropriate places, start Openfire, and tail the logfile.
Connecting To Openfire
You'll be able to connect by opening a browser and going to http://localhost:9090,
optionally replacing localhost with the hostname or IP of your Docker host system.
If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.
As long as you start future iterations of the container from this directory, changes to the configuration,
plugins, and the embedded database will be preserved.
Installing SSL Certificates
For ease in installing SSL certificates, see this post.
Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter
is provided in case your origin container only provides the JRE.
  1. Connect to the container and start a shell
     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security
In case that post disappears in the future, an abridged version of it is saved here.
Upgrading The Container (minor versions)
When the time comes to upgrade the container, it's quite simple.
  1. Stop and remove the existing container with docker kill and docker rm. All of your data is
persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.
Upgrading from Openfire 3 to Openfire 4
Caveats
  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user
Upgrade Steps
  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:

    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means
About
Docker container build/run env for Openfire XMPP server
Resources
Readme
Activity
Stars
6 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - oskapt/docker-openfire: Docker container build/run env for Openfire XMPP server · GitHub
Skip to content
BranchesTags
Repository files navigation
Openfire Docker Container
This will build a vanilla installation of Openfire
inside of a Docker container. Because Openfire wants persistent data, I've copied over
the vanilla contents of the following directories to be mounted as persistent volumes.
  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins
Building The Container
If you prefer to build the container yourself, you'll need to do some prep work.
  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.
Running The Container
Copy the contents of the run directory to a location on the filesystem from where you run containers.
I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.
Via Docker Compose
  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.
Manually
  1. From $rundir, optionally edit the run.sh file to change the tag for the
container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their
appropriate places, start Openfire, and tail the logfile.
Connecting To Openfire
You'll be able to connect by opening a browser and going to http://localhost:9090,
optionally replacing localhost with the hostname or IP of your Docker host system.
If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.
As long as you start future iterations of the container from this directory, changes to the configuration,
plugins, and the embedded database will be preserved.
Installing SSL Certificates
For ease in installing SSL certificates, see this post.
Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter
is provided in case your origin container only provides the JRE.
  1. Connect to the container and start a shell
     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security
In case that post disappears in the future, an abridged version of it is saved here.
Upgrading The Container (minor versions)
When the time comes to upgrade the container, it's quite simple.
  1. Stop and remove the existing container with docker kill and docker rm. All of your data is
persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.
Upgrading from Openfire 3 to Openfire 4
Caveats
  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user
Upgrade Steps
  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:

    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means
About
Docker container build/run env for Openfire XMPP server
Resources
Readme
Activity
Stars
6 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - oskapt/docker-openfire: Docker container build/run env for Openfire XMPP server · GitHub
Skip to content
BranchesTags
Repository files navigation
Openfire Docker Container
This will build a vanilla installation of Openfire
inside of a Docker container. Because Openfire wants persistent data, I've copied over
the vanilla contents of the following directories to be mounted as persistent volumes.
  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins
Building The Container
If you prefer to build the container yourself, you'll need to do some prep work.
  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.
Running The Container
Copy the contents of the run directory to a location on the filesystem from where you run containers.
I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.
Via Docker Compose
  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.
Manually
  1. From $rundir, optionally edit the run.sh file to change the tag for the
container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their
appropriate places, start Openfire, and tail the logfile.
Connecting To Openfire
You'll be able to connect by opening a browser and going to http://localhost:9090,
optionally replacing localhost with the hostname or IP of your Docker host system.
If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.
As long as you start future iterations of the container from this directory, changes to the configuration,
plugins, and the embedded database will be preserved.
Installing SSL Certificates
For ease in installing SSL certificates, see this post.
Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter
is provided in case your origin container only provides the JRE.
  1. Connect to the container and start a shell
     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security
In case that post disappears in the future, an abridged version of it is saved here.
Upgrading The Container (minor versions)
When the time comes to upgrade the container, it's quite simple.
  1. Stop and remove the existing container with docker kill and docker rm. All of your data is
persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.
Upgrading from Openfire 3 to Openfire 4
Caveats
  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user
Upgrade Steps
  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:

    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means
About
Docker container build/run env for Openfire XMPP server
Resources
Readme
Activity
Stars
6 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - oskapt/docker-openfire: Docker container build/run env for Openfire XMPP server · GitHub
Skip to content
BranchesTags
Repository files navigation
Openfire Docker Container
This will build a vanilla installation of Openfire
inside of a Docker container. Because Openfire wants persistent data, I've copied over
the vanilla contents of the following directories to be mounted as persistent volumes.
  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins
Building The Container
If you prefer to build the container yourself, you'll need to do some prep work.
  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.
Running The Container
Copy the contents of the run directory to a location on the filesystem from where you run containers.
I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.
Via Docker Compose
  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.
Manually
  1. From $rundir, optionally edit the run.sh file to change the tag for the
container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their
appropriate places, start Openfire, and tail the logfile.
Connecting To Openfire
You'll be able to connect by opening a browser and going to http://localhost:9090,
optionally replacing localhost with the hostname or IP of your Docker host system.
If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.
As long as you start future iterations of the container from this directory, changes to the configuration,
plugins, and the embedded database will be preserved.
Installing SSL Certificates
For ease in installing SSL certificates, see this post.
Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter
is provided in case your origin container only provides the JRE.
  1. Connect to the container and start a shell
     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security
In case that post disappears in the future, an abridged version of it is saved here.
Upgrading The Container (minor versions)
When the time comes to upgrade the container, it's quite simple.
  1. Stop and remove the existing container with docker kill and docker rm. All of your data is
persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.
Upgrading from Openfire 3 to Openfire 4
Caveats
  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user
Upgrade Steps
  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:

    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means
About
Docker container build/run env for Openfire XMPP server
Resources
Readme
Activity
Stars
6 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - oskapt/docker-openfire: Docker container build/run env for Openfire XMPP server · GitHub
Skip to content
BranchesTags
Repository files navigation
Openfire Docker Container
This will build a vanilla installation of Openfire
inside of a Docker container. Because Openfire wants persistent data, I've copied over
the vanilla contents of the following directories to be mounted as persistent volumes.
  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins
Building The Container
If you prefer to build the container yourself, you'll need to do some prep work.
  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.
Running The Container
Copy the contents of the run directory to a location on the filesystem from where you run containers.
I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.
Via Docker Compose
  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.
Manually
  1. From $rundir, optionally edit the run.sh file to change the tag for the
container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their
appropriate places, start Openfire, and tail the logfile.
Connecting To Openfire
You'll be able to connect by opening a browser and going to http://localhost:9090,
optionally replacing localhost with the hostname or IP of your Docker host system.
If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.
As long as you start future iterations of the container from this directory, changes to the configuration,
plugins, and the embedded database will be preserved.
Installing SSL Certificates
For ease in installing SSL certificates, see this post.
Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter
is provided in case your origin container only provides the JRE.
  1. Connect to the container and start a shell
     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security
In case that post disappears in the future, an abridged version of it is saved here.
Upgrading The Container (minor versions)
When the time comes to upgrade the container, it's quite simple.
  1. Stop and remove the existing container with docker kill and docker rm. All of your data is
persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.
Upgrading from Openfire 3 to Openfire 4
Caveats
  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user
Upgrade Steps
  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:

    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means
About
Docker container build/run env for Openfire XMPP server
Resources
Readme
Activity
Stars
6 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - oskapt/docker-openfire: Docker container build/run env for Openfire XMPP server · GitHub
Skip to content
BranchesTags
Repository files navigation
Openfire Docker Container
This will build a vanilla installation of Openfire
inside of a Docker container. Because Openfire wants persistent data, I've copied over
the vanilla contents of the following directories to be mounted as persistent volumes.
  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins
Building The Container
If you prefer to build the container yourself, you'll need to do some prep work.
  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.
Running The Container
Copy the contents of the run directory to a location on the filesystem from where you run containers.
I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.
Via Docker Compose
  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.
Manually
  1. From $rundir, optionally edit the run.sh file to change the tag for the
container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their
appropriate places, start Openfire, and tail the logfile.
Connecting To Openfire
You'll be able to connect by opening a browser and going to http://localhost:9090,
optionally replacing localhost with the hostname or IP of your Docker host system.
If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.
As long as you start future iterations of the container from this directory, changes to the configuration,
plugins, and the embedded database will be preserved.
Installing SSL Certificates
For ease in installing SSL certificates, see this post.
Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter
is provided in case your origin container only provides the JRE.
  1. Connect to the container and start a shell
     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security
In case that post disappears in the future, an abridged version of it is saved here.
Upgrading The Container (minor versions)
When the time comes to upgrade the container, it's quite simple.
  1. Stop and remove the existing container with docker kill and docker rm. All of your data is
persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.
Upgrading from Openfire 3 to Openfire 4
Caveats
  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user
Upgrade Steps
  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:

    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means
About
Docker container build/run env for Openfire XMPP server
Resources
Readme
Activity
Stars
6 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - oskapt/docker-openfire: Docker container build/run env for Openfire XMPP server · GitHub
Skip to content
BranchesTags
Repository files navigation
Openfire Docker Container
This will build a vanilla installation of Openfire
inside of a Docker container. Because Openfire wants persistent data, I've copied over
the vanilla contents of the following directories to be mounted as persistent volumes.
  • /usr/share/openfire/conf
  • /usr/share/openfire/resources/security
  • /usr/share/openfire/embedded-db
  • /usr/share/openfire/plugins
Building The Container
If you prefer to build the container yourself, you'll need to do some prep work.
  1. Enter the build directory.
  2. Review the Dockerfile for the version of Openfire that you wish to install. Change the environment variable OF_VERSION to match.
  3. While you're there, review the version of dumb-init. If you need to change it, change the DI_VERSION environment variable.
  4. . Run docker build and optionally give it a tag that you like.
Running The Container
Copy the contents of the run directory to a location on the filesystem from where you run containers.
I keep all container operations under /opt/docker/<container>, so for the rest of this document I'll presume /opt/docker/openfire, which I'll refer to as $rundir.
Via Docker Compose
  1. From $rundir, optionally edit docker-compose.yml to change the tag for the container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Run docker-compose up to start the container in the foreground or docker-compose up -d to start it in the background.
Manually
  1. From $rundir, optionally edit the run.sh file to change the tag for the
container.
  2. If you don't want to use the admin console over HTTP, remove 9090 from the ports config.
  3. Execute run.sh to kick off the container. This will mount the directories in their
appropriate places, start Openfire, and tail the logfile.
Connecting To Openfire
You'll be able to connect by opening a browser and going to http://localhost:9090,
optionally replacing localhost with the hostname or IP of your Docker host system.
If you're doing an upgrade and have configured TLS, you'll be able to connect to the admin console over HTTPS on port 9091.
As long as you start future iterations of the container from this directory, changes to the configuration,
plugins, and the embedded database will be preserved.
Installing SSL Certificates
For ease in installing SSL certificates, see this post.
Both KeyStoreImport.java and KeyStoreImport.class are contained in this repository, in the security folder. The latter
is provided in case your origin container only provides the JRE.
  1. Connect to the container and start a shell
     $ docker run -it monachus/openfire /bin/ash

  2. Follow along with the post, changing /etc/openfire/security to /usr/share/openfire/resources/security
In case that post disappears in the future, an abridged version of it is saved here.
Upgrading The Container (minor versions)
When the time comes to upgrade the container, it's quite simple.
  1. Stop and remove the existing container with docker kill and docker rm. All of your data is
persistent.
  2. Make a backup of $rundir just in case something goes south.
  3. Follow the build steps from above for the latest version of Openfire.
  4. Start your new container.
  5. If everything went well, remove the backups.
Upgrading from Openfire 3 to Openfire 4
Caveats
  • /etc/openfire is now /usr/share/openfire/conf
  • There is no more lib directory. Plugins are at the top level.
  • /etc/openfire/security is now /resources/security
  • Openfire runs as daemon instead of its own user
Upgrade Steps
  1. Backup lib/embedded-db, lib/plugins, and etc
  2. Stop and remove the v3 container.
  3. Rename your current $rundir to $rundir.old
  4. From this source copy run to $rundir (creating a new directory)
  5. From your backups, copy the following:

    • The contents of etc/security to security
    • The remaining contents of etc to conf (excluding the security folder)
    • The contents of lib/plugins to pluginsexcept the admin folder
    • The contents of lib/embedded-db to embedded-db
  6. Restart the container via your chosen means
About
Docker container build/run env for Openfire XMPP server
Resources
Readme
Activity
Stars
6 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages