The Coozila! Package for Memcached Cluster integrates DragonflyDB and McRouter, offering a state-of-the-art caching solution tailored for modern applications. This package is designed to maximize scalability and performance, enabling developers to deploy distributed caching layers effortlessly, reduce database load, and significantly improve response times.
Why Choose Coozila?
- Simplified Scalability: Deploy a highly efficient distributed caching layer with pre-configured Docker packages, reducing complexity and ensuring faster response times.
- Intelligent Request Routing: Utilize McRouter’s advanced features, such as prefix routing, replicated pools, and failover mechanisms, for seamless cache operation.
- Blazing-Fast Performance: Built on DragonflyDB, Coozila! delivers a high-speed, fault-tolerant caching system optimized for high-demand environments.
- Dynamic Configuration: Manage and scale your caching infrastructure with live updates, ensuring zero downtime.
- Multi-Level Caching: Implement tiered caching for enhanced data retrieval efficiency.
Core Features
- High Availability: Ensure reliable data storage with integrated failover and replication mechanisms.
- Optimized Caching: Route requests efficiently across multiple Memcached servers using McRouter for better load balancing and resource management.
- Advanced Routing Logic: Configure routing policies based on prefixes, clusters, or custom requirements using McRouter’s modular routing handles.
- Cold Cache Warmup: Seamlessly bring new cache nodes online without impacting application performance.
- Rich Monitoring Tools: Access detailed statistics and debugging tools for complete visibility into cache performance.
- Security First: Protect data in transit with SSL support and IPv6 compatibility.
- Multi-Threaded Architecture: Leverage multi-core systems for efficient request handling.
Easy Deployment
This package includes pre-configured Docker containers and a straightforward setup process, enabling developers to quickly build a scalable, reliable caching infrastructure.
Included in Your Offer
- One Nginx Server: Optimized for web traffic management.
- One Caddy Server: Efficient reverse proxy capabilities.
- One PHP Server: Pre-configured for Memcached integration.
- One McRouter Server: Intelligent request routing for optimal caching.
- Three DragonFlyDB Memcached Servers: Integrated with your existing database and website.
Note: Each “server” refers to one Docker container. All containers can run on the same physical machine or in the cloud for performance and redundancy.
Recommended Server Specifications
For the Cluster configuration, we recommend using a cloud server instance with the following specifications:
- Minimum RAM: 12 GB (This is the minimum requirement to run the cluster effectively for production.) We have tested the application with 8 GB of RAM, and it functions perfectly, as Docker consumes very little memory. However, to achieve maximum speed, the application requires this amount of RAM, which also depends on the quantity of cache on your server. If the RAM fills up quickly, the application’s performance will degrade rapidly, as it runs solely in RAM.
- The data is saved both on disk, and a snapshot of the program data is created. If your server has less memory, only a single instance of DragonflyDB can be run. However, in this case, the cluster loses its significance. A single instance of DragonflyDB requires a minimum of 4 GB of RAM to run effectively.
- Maximum RAM Supported: Each DragonflyDB instance can support up to 768 GB of RAM, allowing for extensive caching capabilities. With 3 instances configured, the effective storage capacity will be 2.274 TB. This configuration is cost-effective and suitable for applications with light to moderate traffic.
- The DragonflyDB Cluster project is paving the way for a new generation of caching systems, delivering exceptional performance and scalability. Designed to handle demanding workloads, the most advanced configuration of DragonflyDB Cluster offers the ability to process up to 4.6 TB of data in a mirrored setup (replication). The effective storage capacity will be 2.304 TB (or 2,304 GB), as the data is duplicated across the mirrored instances, making it an ideal choice for large-scale applications.
- The application can set a limit on the RAM that can be used. If you have unlimited memory, you can set it to manage automatically, and DragonflyDB will manage its memory based on the available memory on the server.
However, a custom cluster can be configured without limitations and can be horizontally scaled across different geographical areas or within the same data center based on your preferences. For more advanced options, this custom cluster can run in a Multi-Cloud, Multi-Cluster Kubernetes Orchestration setup with Karmada across multiple data centers and with various cloud providers globally, without any limitations.
Multiple Configurations for Diverse Needs
DragonflyDB Cluster provides several configurations to suit a variety of use cases:
- Basic setup: for smaller-scale applications or testing environments.
- Advanced setup: featuring three routers, three master nodes, and three slave nodes, optimized for performance, fault tolerance, and high availability. If you have a minimum of three servers available for caching, we can install a package on each of them. Each server will have one router and two instances: one DragonflyDB master and one DragonflyDB slave. Additionally, we will set up three Nginx proxy servers in front, along with a load balancer.
- For high availability (HA), a total of six instances are required, which means you will need a minimum of six servers, each with one instance of DragonflyDB. In this case, you will have three master nodes and three slave nodes operating in a mirrored setup, so the available memory will be effectively halved.
If you would like to proceed with this option, please contact us via email first, as this package only includes the basic version with one router and three DragonflyDB instances. For more advanced configurations, please contact us via email for a tailored offer.
Key Advantages
- Unparalleled Speed: With performance that can reach up to 25x faster than traditional Memcached, DragonflyDB Cluster is designed for use cases where speed is critical.
- Scalability: The cluster’s advanced architecture supports scaling up to 4.6 TB, offering exceptional capacity for handling massive datasets.
- Flexibility: Adaptable to a wide range of scenarios, users can customize configurations to optimize for their specific requirements.
Handle with Care: Development Status
As a project still under development, the DragonflyDB Cluster team advises users to:
- Test thoroughly in controlled environments before production deployment.
- Adjust configurations to match individual use cases for optimal results.
- Verify licenses to ensure compliance with all third-party dependencies and integrations.
Licenses
- Coozila!: MIT License
- DragonflyDB: DragonflyDB License
- McRouter: McRouter License
- Memcached: Memcached License
Important Notice Regarding DragonflyDB Usage
In compliance with the Dragonfly Business Source License 1.1 (BSL 1.1):
- Permitted Use: This project involves installing and configuring DragonflyDB as part of your private caching infrastructure.
- Prohibited Use: You cannot offer DragonflyDB as a hosted or managed service, nor provide any solution that allows third parties (other than your employees or contractors) to access or use DragonflyDB features.
- One-Time Installation: You can only order a one-time installation for a managed solution. You need to contact the DragonflyDB team to ensure that the service fully respects the licensing terms of DragonflyDB, or you can manage it yourself.
Explore and Contribute
Learn more and become part of the journey by visiting the Coozila! repository:
Installation Assistance
If you would like assistance with the installation of this product, please contact Coozila! Labs at labs@coozila.com. Our team is ready to help you with the installation process and ensure a smooth setup.
Based on the size and complexity of your project, we will provide you with a tailored pricing quote.
For purchasing the installation service, you can place an order here or please visit the following link: Coozila Docker Package App for Memcached.
You can also check out the official Coozila! Labs page for more information: Coozila! Labs.
For any inquiries, feel free to reach out through our contact page: Contact Coozila!.
After Purchase Notes
After your purchase, please provide the following information via email:
- Server login credentials
- An SSH key for secure access
- Details about the project you wish to integrate
Additional Documentation
For more details, please refer to the main repository:
Disclaimer
This product is provided "as is," without any guarantees or warranties regarding its functionality, performance, or reliability. By using this product, you acknowledge that you do so at your own risk. Coozila! and its contributors are not liable for any issues, damages, or losses that may arise from the use of this product. We recommend thoroughly testing the product in your own environment before deploying it in a production setting.
Deprecated: Automatic conversion of false to array is deprecated in /opt/una/modules/boonex/albums/classes/BxAlbumsSearchResult.php on line 19
"Latest album" and "Update album" block in homepage get this error album versions 14.0.4
- 2663
The DragonflyDB Cluster project is paving the way for a new generation of caching systems, delivering exceptional performance and scalability. Designed to handle demanding workloads, the most advanced configuration of DragonflyDB Cluster offers the ability to process up to 4.6 TB of data in a mirrored setup (replication), the effective storage capacity will be 2.304 TB (or 2,304 GB), as the data is duplicated across the mirrored instances, making it an ideal choice for large-scale applications.
Multiple Configurations for Diverse Needs
DragonflyDB Cluster provides several configurations to suit a variety of use cases:
- Basic setups for smaller-scale applications or testing environments.
- Advanced setups featuring three routers, three master nodes, and three slave nodes, optimized for performance, fault tolerance, and high availability.
Key Advantages
- Unparalleled Speed: With performance that can reach up to 25x faster than traditional Memcached, DragonflyDB Cluster is designed for use cases where speed is critical.
- Scalability: The cluster’s advanced architecture supports scaling up to 4.6 TB, offering exceptional capacity for handling massive datasets.
- Flexibility: Adaptable to a wide range of scenarios, users can customize configurations to optimize for their specific requirements.
Handle with Care: Development Status
As a project still under development, the DragonflyDB Cluster team advises users to:
- Test thoroughly in controlled environments before production deployment.
- Adjust configurations to match individual use cases for optimal results.
- Verify licenses to ensure compliance with all third-party dependencies and integrations.
Licenses
- Coozila!: MIT License
- DragonflyDB: DragonflyDB License
- McRouter: McRouter License
- Memcached: Memcached License
Important Notice Regarding DragonflyDB Usage
In compliance with the Dragonfly Business Source License 1.1 (BSL 1.1):
- Permitted Use: This project involves installing and configuring DragonflyDB as part of your private caching infrastructure.
- Prohibited Use: You cannot offer DragonflyDB as a hosted or managed service, nor provide any solution that allows third parties (other than your employees or contractors) to access or use DragonflyDB features.
- This ensures that the service fully respects the licensing terms of DragonflyDB.
Explore and Contribute
Learn more and become part of the journey by visiting the Coozila! repository:
Installation Assistance
If you would like assistance with the installation of this product, please contact Coozila! Labs at labs@coozila.com. Our team is ready to help you with the installation process and ensure a smooth setup.
Based on the size and complexity of your project, we will provide you with a tailored pricing quote.
For purchasing the installation service, please visit the following link: Coozila Docker Package App for Memcached.
You can also check out the official Coozila! Labs page for more information: Coozila! Labs.
For any inquiries, feel free to reach out through our contact page: Contact Coozila!.
After Purchase Notes
After your purchase, please provide the following information via email:
- Server login credentials
- An SSH key for secure access
- Details about the project you wish to integrate
Additional Documentation
For more details, please refer to the main repository:
Disclaimer
This product is provided "as is," without any guarantees or warranties regarding its functionality, performance, or reliability. By using this product, you acknowledge that you do so at your own risk. Coozila! and its contributors are not liable for any issues, damages, or losses that may arise from the use of this product. We recommend thoroughly testing the product in your own environment before deploying it in a production setting.
In the album module version 14.0.0-RC2, the option to delete pictures from the view picture page is not functioning, indicating a problem within the module itself, including contexts like the Space module.
- 1003
In UNA 14.0.0-RC2, I noticed that the "next image" arrow remains visible even when the user reaches the first or last image in an album. This issue was resolved in Dolphin in the past but seems to persist in UNA.
Steps to Reproduce:
- Open an image album in UNA.
- Navigate through the images using the "next image" arrow.
- Once you reach the last image, observe that the "next image" arrow is still visible, even though there are no more images to display.
Expected Behavior:
The "next image" arrow should disappear when the user reaches the last image in the album.
Additional Information:
- UNA Version: 14.0.0-RC2
- Browser Tested: Chrome, Firefox
Please investigate and address this issue. Thank you!
- 1060
I don’t understand why UNA should use these outdated applications. Mutation Events, including DOMSubtreeModified
, DOMNodeInserted
, DOMNodeRemoved
, DOMNodeRemovedFromDocument
, DOMNodeInsertedIntoDocument
, and DOMCharacterDataModified
, are detrimental to page performance and significantly increase the complexity of adding new features to the Web. These APIs were deprecated from the specification (iconSpec: UI Events) in 2011 and were replaced by the much better-behaved Mutation Observer API in 2012. The usage of the obsolete Mutation Events must now be migrated to the Mutation Observer.
[Deprecation] Listener added for a 'DOMNodeInserted' mutation event. Support for this event type has been removed, and this event will no longer be fired. See https://chromestatus.com/feature/5083947249172480 for more information.
r.domNode.addEventListener("DOMNodeInserted", function() {}),
in
function e(t, n) {
o(this, e);
var r = i(this, (e.__proto__ || Object.getPrototypeOf(e)).call(this, t));
return r.emitter = n.emitter,
Array.isArray(n.whitelist) && (r.whitelist = n.whitelist.reduce(function(t, e) {
return t[e] = !0,
t
}, {})),
r.domNode.addEventListener("DOMNodeInserted", function() {}),
r.optimize(),
r.enable(),
r
}
In relation to the #Spaces product, the concept is clear: this module enables users to organize groups, called Spaces, in a nested hierarchy, where each ‘Parent Space’ can contain multiple ‘Child Spaces.’ This structure allows for extensive customization and flexibility in organizing content and groups.
However, this arrangement brings significant privacy challenges. Each Space comes with its own permissions and member controls, allowing users to manage their access at every level. While this offers flexibility, it becomes problematic when the names and links of these Spaces appear in autocomplete search results. If a secret or closed Space, intended to remain confidential, is included in search results, it undermines the core principle of a private space.
The module’s ability to support Communities and Sub-Communities is a valuable asset. For instance, on a platform dedicated to International Soccer/Football, a Parent Space could represent countries, while Child Spaces could represent individual teams. Users following a country could be automatically enrolled in related teams but should retain the option to follow only specific teams.
To uphold privacy within Spaces, all content and associated details must be accessible only to the creator and invited members. If such content becomes publicly searchable, it defeats the purpose of having private or secret Spaces. Ultimately, for the Spaces module to be effective, sensitive information must remain protected, and the principles of privacy must be respected.
According to the Cambridge Dictionary,
"If something is secret, other people are not allowed to know about it."
Therefore, if the titles of secret spaces and their content appear in public search results(even for unregistered users), they are no longer secret, and the definition of a secret space and secret content loses its meaning.
- 2487
Hi, UNA looks good, but the problem is that it's shaking in all its joints.
I raised a similar concern back in 2018, but it seems like the issue has still not been addressed. Every time I navigate to a different page or section across the entire site, the header reloads completely, even though nothing in the header has changed. This causes unnecessary bandwidth consumption and disrupts the user experience, as it feels like the page is being reloaded from scratch each time.
In the era of AI and modern web development practices, it seems inefficient and unnecessary for the header to reload completely when nothing has changed in it. This behavior consumes unnecessary bandwidth and creates a less smooth user experience, especially when navigating between pages. It's frustrating to experience this lack of optimization, as it feels like the platform hasn't kept up with modern standards. Navigating through UNA feels like browsing a website from 20 years ago, rather than using a modern platform.
Is there any way to prevent the header from reloading every time a user navigates between different pages or sections on the site? A solution that uses AJAX, caching, or other modern techniques would drastically improve the site’s performance and user experience.
When will this issue be resolved? I want to build a site using UNA, but I don't have the courage to launch something with such an outdated interface. People would laugh if they saw it, and I can’t afford that.
When I navigate, it feels like the entire header is trembling, like an old car ready to fall apart from all its joints.
I would appreciate any suggestions or solutions on how to resolve this issue.
- 1085
Hello,
I am working with UNA and I am looking to implement a feature that would display related content like videos, files, photos, post etc on a module page. In the past, Dolphin CMS had a built-in functionality for this, but I have found that this feature is no longer available in UNA.
Could anyone provide guidance or a solution for implementing related content in UNA? Specifically, I need to:
- Fetch and display related videos based on tags or categories.
- Display related files, photos , posts etc in a similar manner.
- Ensure that the content is fetched dynamically and rendered correctly in the module page template.
I understand that UNA may have a different structure than Dolphin, so I would appreciate any advice on where to add this functionality or if there are existing methods or services in UNA that I can utilize for this purpose.
I identified some changes that need to be added to create an HTML block for related videos in the UNA script. Here's how you can implement it:In video en.xml:
```xml
<string name="_bx_videos_menu_item_title_system_entries_related">string>
<string name="_bx_videos_menu_item_title_entries_related">string>```
and english en.xml
```xml
<string name="_cmt_load_more_comments_related">string>
<string name="_cmt_load_more_replies_related">string>
<string name="_adm_block_cpt_related">string>
<string name="_adm_lmi_cpt_related">string>
<string name="_cmt_browse_related">string>
```
In enable.sql:
```sql
-- PAGE: related entries
INSERT INTO `sys_objects_page`(`object`, `title_system`, `title`, `module`, `layout_id`, `visible_for_levels`, `visible_for_levels_editable`, `uri`, `url`, `meta_description`, `meta_keywords`, `meta_robots`, `cache_lifetime`, `cache_editable`, `deletable`, `override_class_name`, `override_class_file`) VALUES
('bx_videos_related', '_bx_videos_page_title_sys_entries_related', '_bx_videos_page_title_entries_related', 'bx_videos', 5, 2147483647, 1, 'videos-related', 'page.php?i=videos-related', '', '', '', 0, 1, 0, 'BxVideosPageBrowse', 'modules/boonex/videos/classes/BxVideosPageBrowse.php');
INSERT INTO `sys_pages_blocks`(`object`, `cell_id`, `module`, `title`, `designbox_id`, `visible_for_levels`, `type`, `content`, `deletable`, `copyable`, `order`) VALUES
('bx_videos_related', 1, 'bx_videos', '_bx_videos_page_block_title_related_entries', 11, 2147483647, 'service', 'a:3:{s:6:"module";s:9:"bx_videos";s:6:"method";s:14:"browse_related";s:6:"params";a:3:{s:9:"unit_view";s:7:"gallery";s:13:"empty_message";b:1;s:13:"ajax_paginate";b:0;}}', 0, 1, 1);
```
In BxVideosConfig.php:
```php
// Page URIs
'URL_RELATED' => 'page.php?i=videos-related',
```
In BxVideosSearchResult.php:
```php
case 'related':
$this->sBrowseUrl = BxDolPermalinks::getInstance()->permalink($CNF['URL_RELATED']);
$this->aCurrent['title'] = _t('_bx_videos_page_title_browse_related');
$this->aCurrent['rss']['link'] = 'modules/?r=videos/rss/' . $sMode;
$this->aCurrent['sorting'] = 'related';
break;
```
In BxBaseModTextSearchResult.php:
```php
case 'related':
$aSql['order'] = ' ORDER BY `' . $sTable . '`.`' . $CNF['FIELD_VIEWS'] . '` DESC';
break;
```
This should successfully add a "Related Videos" page and block functionality to the UNA platform. Can someone help me identify what I did wrong and what might be missing? To display the results, they need to be generated dunamicaly based on tags and categories ad related keywords. At what level should the PHP code responsible for generating these results be implemented? A list o files wil be nice
Thank you in advance for your help!