Multisite is a powerful new feature that arrived with the release of WordPress 3.0. It allows website managers to host multiple independent websites with a single installation of WordPress. Although each “website” in a network is independent, there are many ways to share settings, code and content throughout the entire network.
Since the beginning of the year, I’ve been developing themes and plugins for a WordPress Multisite-powered content network. During that time I’ve learned many powerful tips and tricks unique to Multisite. This guide will introduce you to a few Multisite-specific functions, along with real-world programming examples that you can begin using today. Hopefully, it will open your eyes to a few of the new possibilities available in Multisite.
Managing multiple websites with a single installation of WordPress enables you to easily upgrade the core, plugins and themes for every website in a network. You can share functionality across multiple websites with network plugins, as well as standardize design elements across multiple websites using a parent theme.
Multisite stores global options in the
In this example, I’ve used the
This small snippet of code will display the following HTML:
Many useful Multisite functions can be found in the
The SQL query we’ve created in this example has the potential to become very large, possibly causing performance issues. For this reason, we’ll use the Transients API, which enables us to temporarily store a cached version of the results as network website “transients” in the
Transients provide a simple and standardized way to store cached data in the database for a set period of time, after which the data expires and is deleted. It’s very similar to storing information with the Options API, except that it has the added value of an expiration time. Transients are also sped up by caching plugins, whereas normal options aren’t. Due to the nature of the expiration process, never assume that a transient is in the database when writing code.
The SQL query will run every two hours, and the actual data will be returned from the transient, making things much more efficient. I’ve included two parameters,
One of the most powerful elements of this example is the use of
Add the following to your theme’s functions.php file:
(Please note: The
This function first verifies that Multisite is enabled and, if it’s not, returns
To use this in your theme, call the
This SQL query also has the potential to become very large. For this reason, we’ll use the Transients API again in a method very similar to what is used in the
Start by adding the
Using this function in your theme is simple. Be certain to check the
For example, you may want to display
Did you notice that the entire
When would you use this
This is only one of many ways you can use the
Since the beginning of the year, I’ve been developing themes and plugins for a WordPress Multisite-powered content network. During that time I’ve learned many powerful tips and tricks unique to Multisite. This guide will introduce you to a few Multisite-specific functions, along with real-world programming examples that you can begin using today. Hopefully, it will open your eyes to a few of the new possibilities available in Multisite.
Why Use Multisite?
Multisite is a great option for freelancers, businesses and organizations that manage multiple WordPress websites. Whether you’re a freelancer who wants to provide hosting and maintenance to clients, a college organization looking to centralize the management of your websites, or a large news publisher trying to isolate silos for different departments, Multisite is the answer.Managing multiple websites with a single installation of WordPress enables you to easily upgrade the core, plugins and themes for every website in a network. You can share functionality across multiple websites with network plugins, as well as standardize design elements across multiple websites using a parent theme.
Overview of Benefits
- Users are able to easily access and manage multiple websites with a single user account and profile.
- Users can access a particular website or every website using the same account.
- Information from one website can be completely isolated from others.
- Information from one website can be easily shared with others.
- Updates and upgrades can be rolled out across multiple websites in less time, reducing overhead and maintenance costs.
- Customizations to WordPress can be efficiently distributed in a centralized, cascading method using network-wide plugins.
Working With Multisite Functions
Multisite-enabled WordPress installations contain additional functions and features that theme developers can use to improve the experience of a website. If you find yourself developing themes and plugins for WordPress Multisite, consider the following tips to customize and improve the connectivity of the network.Displaying Information About a Network
You might find yourself in a situation where you would like to display the number of websites or users in your network. Providing a link to the network’s primary website would also be nice, so that visitors can learn more about your organization.Multisite stores global options in the
wp_sitemeta database table, such as the network’s name (site_name), the administrator’s email address (admin_email) and the primary website’s URL (siteurl). To access these options, you can use the get_site_option() function.In this example, I’ve used the
get_site_option() function along with get_blog_count() and get_user_count() to display a sentence with details about a network.1 | |
2 |
3 | The |
4 |
5 | |
1 | The <a href="http://www.smashingmagazine.com">Smashing Magazine network |
/wp-includes/ms-functions.php file. I highly suggest browsing the Trac project yourself. It’s a great way to find new functions and to become familiar with WordPress coding standards.Build a Network Navigation Menu
Many networks have consistent dynamic navigation that appears on all websites, making it easy for visitors to browse the network. Using the$wpdb database class, along with the get_site_url(), home_url(), get_current_blog_id(), switch_to_blog() and restore_current_blog() functions, we can create a fully dynamic network menu, including a class (.current-site-item) to highlight the current website.The SQL query we’ve created in this example has the potential to become very large, possibly causing performance issues. For this reason, we’ll use the Transients API, which enables us to temporarily store a cached version of the results as network website “transients” in the
sitemeta table using the set_site_transient() and get_site_transient() functions.Transients provide a simple and standardized way to store cached data in the database for a set period of time, after which the data expires and is deleted. It’s very similar to storing information with the Options API, except that it has the added value of an expiration time. Transients are also sped up by caching plugins, whereas normal options aren’t. Due to the nature of the expiration process, never assume that a transient is in the database when writing code.
The SQL query will run every two hours, and the actual data will be returned from the transient, making things much more efficient. I’ve included two parameters,
$size and $expires, allowing you to control the number of posts returned and the expiration time for the transient.One of the most powerful elements of this example is the use of
switch_to_blog() and restore_current_blog(). These two Multisite functions enable us to temporarily switch to another website (by ID), gather information or content, and then switch back to the original website.Add the following to your theme’s functions.php file:
01 | /** |
02 | * Build a list of all websites in a network |
03 | */ |
04 | function wp_list_sites( $expires = 7200 ) { |
05 | if( !is_multisite() ) return false; |
06 |
07 | // Because the get_blog_list() function is currently flagged as deprecated |
08 | // due to the potential for high consumption of resources, we'll use |
09 | // $wpdb to roll out our own SQL query instead. Because the query can be |
10 | // memory-intensive, we'll store the results using the Transients API |
11 | if ( false === ( $site_list = get_transient( 'multisite_site_list' ) ) ) { |
12 | global $wpdb; |
13 | $site_list = $wpdb->get_results( $wpdb->prepare('SELECT * FROM wp_blogs ORDER BY blog_id') ); |
14 | // Set the Transient cache to expire every two hours |
15 | set_site_transient( 'multisite_site_list', $site_list, $expires ); |
16 | } |
17 |
18 | $current_site_url = get_site_url( get_current_blog_id() ); |
19 |
20 | $html = ' |
21 | |
22 |
23 | foreach ( $site_list as $site ) { |
24 | switch_to_blog( $site->blog_id ); |
25 | $class = ( home_url() == $current_site_url ) ? ' class="current-site-item"' : ''; |
26 | $html .= "\t" . ' |
27 | |
28 |
29 | ' . "\n"; |
30 | restore_current_blog(); |
31 | } |
32 |
33 | $html .= ' |
34 |
35 | ' . "\n\n"; |
36 |
37 | return $html; |
38 | } |
get_blog_list() function is currently deprecated due to the potential for a high consumption of resources if a network contains more than 1000 websites. Currently, there is no replacement function, which is why I have used a custom $wpdb query in its place. In future, WordPress developers will probably release a better alternative. I suggest checking for a replacement before implementing this example on an actual network.)This function first verifies that Multisite is enabled and, if it’s not, returns
false. First, we gather a list of IDs of all websites in the network, sorting them in ascending order using our custom $wpdb query. Next, we iterate through each website in the list, using switch_to_blog() to check whether it is the current website, and adding the .current-site-item class if it is. Then, we use the name and link for that website to create a list item for our menu, returning to the original website using restore_current_blog(). When the loop is complete, we return the complete unordered list to be outputted in our theme. It’s that simple.To use this in your theme, call the
wp_list_sites() function where you want the network menu to be displayed. Because the function first checks for a Multisite-enabled installation, you should verify that the returned value is not false before displaying the corresponding HTML.01 | |
02 | // Multisite Network Menu |
03 | $network_menu = wp_list_sites(); |
04 | if( $network_menu ): |
05 | ?> |
06 | |
07 | |
08 | |
09 |
10 | |
11 | |
List Recent Posts Across an Entire Network
If the websites in your network share similar topics, you may want to create a list of the most recent posts across all websites. Unfortunately, WordPress does not have a built-in function to do this, but with a little help from the$wpdb database class, you can create a custom database query of the latest posts across your network.This SQL query also has the potential to become very large. For this reason, we’ll use the Transients API again in a method very similar to what is used in the
wp_list_sites() function.Start by adding the
wp_recent_across_network() function to your theme’s functions.php file.01 | /** |
02 | * List recent posts across a Multisite network |
03 | * |
04 | * @uses get_blog_list(), get_blog_permalink() |
05 | * |
06 | * @param int $size The number of results to retrieve |
07 | * @param int $expires Seconds until the transient cache expires |
08 | * @return object Contains the blog_id, post_id, post_date and post_title |
09 | */ |
10 | function wp_recent_across_network( $size = 10, $expires = 7200 ) { |
11 | if( !is_multisite() ) return false; |
12 |
13 | // Cache the results with the WordPress Transients API |
14 | // Get any existing copy of our transient data |
15 | if ( ( $recent_across_network = get_site_transient( 'recent_across_network' ) ) === false ) { |
16 |
17 | // No transient found, regenerate the data and save a new transient |
18 | // Prepare the SQL query with $wpdb |
19 | global $wpdb; |
20 |
21 | $base_prefix = $wpdb->get_blog_prefix(0); |
22 | $base_prefix = str_replace( '1_', '' , $base_prefix ); |
23 |
24 | // Because the get_blog_list() function is currently flagged as deprecated |
25 | // due to the potential for high consumption of resources, we'll use |
26 | // $wpdb to roll out our own SQL query instead. Because the query can be |
27 | // memory-intensive, we'll store the results using the Transients API |
28 | if ( false === ( $site_list = get_site_transient( 'multisite_site_list' ) ) ) { |
29 | global $wpdb; |
30 | $site_list = $wpdb->get_results( $wpdb->prepare('SELECT * FROM wp_blogs ORDER BY blog_id') ); |
31 | set_site_transient( 'multisite_site_list', $site_list, $expires ); |
32 | } |
33 |
34 | $limit = absint($size); |
35 |
36 | // Merge the wp_posts results from all Multisite websites into a single result with MySQL "UNION" |
37 | foreach ( $site_list as $site ) { |
38 | if( $site == $site_list[0] ) { |
39 | $posts_table = $base_prefix . "posts"; |
40 | } else { |
41 | $posts_table = $base_prefix . $site->blog_id . "_posts"; |
42 | } |
43 |
44 | $posts_table = esc_sql( $posts_table ); |
45 | $blogs_table = esc_sql( $base_prefix . 'blogs' ); |
46 |
47 | $query .= "(SELECT $posts_table.ID, $posts_table.post_title, $posts_table.post_date, $blogs_table.blog_id FROM $posts_table, $blogs_table\n"; |
48 | $query .= "\tWHERE $posts_table.post_type = 'post'\n"; |
49 | $query .= "\tAND $posts_table.post_status = 'publish'\n"; |
50 | $query .= "\tAND $blogs_table.blog_id = {$site->blog_id})\n"; |
51 |
52 | if( $site !== end($site_list) ) |
53 | $query .= "UNION\n"; |
54 | else |
55 | $query .= "ORDER BY post_date DESC LIMIT 0, $limit"; |
56 | } |
57 |
58 | // Sanitize and run the query |
59 | $query = $wpdb->prepare($query); |
60 | $recent_across_network = $wpdb->get_results( $query ); |
61 |
62 | // Set the Transients cache to expire every two hours |
63 | set_site_transient( 'recent_across_network', $recent_across_network, 60*60*2 ); |
64 | } |
65 |
66 | // Format the HTML output |
67 | $html = ' |
68 | '; |
69 | foreach ( $recent_across_network as $post ) { |
70 | $html .= ' |
71 | |
72 |
73 | '; |
74 | } |
75 | $html .= ' |
76 |
77 | '; |
78 |
79 | return $html; |
80 | } |
return value before outputting HTML to avoid conflicts with non-Multisite installations.01 | |
02 | // Display recent posts across the entire network |
03 | $recent_network_posts = wp_recent_across_network(); |
04 | if( $recent_network_posts ): |
05 | ?> |
06 | |
07 | |
08 | |
09 |
10 | |
Retrieve a Single Post from Another Website in the Network
In certain situations, you may find it useful to refer to a single page, post or post type from another website in your network. Theget_blog_post() function makes this process simple.For example, you may want to display
the_content() from an “About” page on the primary website in your network.01 | |
02 | // Display "About" page content from the network's primary website |
03 | $about_page = get_blog_post( 1, 317 ); |
04 | if( $about_page ): |
05 | ?> |
06 | |
07 | |
08 | |
09 |
10 | |
$post object is returned? In this example, we’ve used only the_content(), but far more information is available for other circumstances.Set Up Global Variables Across a Network
Starting any WordPress project in a solid local development environment is always important. You might find it handy to have a global variable that determines whether a website is “live” or “staging.” In Multisite, you can achieve this using a network-activated plugin that contains the following handy function, assuming that your local host containslocalhost in the URL:1 | /** |
2 | * Define network globals |
3 | */ |
4 | function ms_define_globals() { |
5 | global $blog_id; |
6 | $GLOBALS['staging'] = ( strstr( $_SERVER['SERVER_NAME'], 'localhost' ) ) ? true : false; |
7 | } |
8 | add_action( 'init', 'ms_define_globals', 1 ); |
$staging variable? I use it to display development-related messages, notifications and information to improve my workflow.Display the Page Request Information in a Local Environment
I use the$staging global variable to display the number of queries and page-request speed for every page across a network in my local environment.01 | /** |
02 | * Display page request info |
03 | * |
04 | * @requires $staging |
05 | */ |
06 | function wp_page_request_info() { |
07 | global $staging; |
08 | if ( $staging ): ?> |
09 | |
10 | |
11 | } |
12 | add_action( 'wp_footer', 'wp_page_request_info', 1000 ); |
ms_define_globals() function. I’ve used it to define, find and replace URLs in the content delivery network, to detect mobile devices and user agents, and to filter local attachment URLs.Conclusion
There is tremendous value in the simplicity of managing multiple websites in a single installation of WordPress. Leveraging WordPress Multisite is quickly becoming a requisite skill among WordPress developers. These techniques should provide a solid foundation for you to build on, so that you can be the next WordPress Multisite theme rock star!Other Resources
- Mastering WordPress Multisite series, WPCandy
- “Create a [Multisite] Network,” WordPress Codex
- “WordPress MultiSite Subdomains on MAMP,” Perishable Press
- “Migrating Multiple Blogs Into WordPress 3.0 Multisite,” WordPress Codex
- OpenView Venture Partners, a live example of a WordPress Multisite network
- “Transients, Caching and the Complexities of Multisite,” The Otto and Nacin Show, WordCamp San Francisco 2011
No comments:
Post a Comment