class.jetpack-autoupdate.php — Jetpack – WP Security, Backup, Speed, & Growth 7.0.3

jetpack / class.jetpack-autoupdate.php

jetpack Last commit date

class.jetpack-autoupdate.php

303 lines

1	<?php
2
3	/**
4	* Handles items that have been selected for automatic updates.
5	* Hooks into WP_Automatic_Updater
6	*/
7	class Jetpack_Autoupdate {
8
9	private $results = array();
10
11	private $expected = array();
12
13	private $success = array(
14	'plugin' => array(),
15	'theme' => array(),
16	);
17
18	private $failed = array(
19	'plugin' => array(),
20	'theme' => array(),
21	);
22
23	private static $instance = null;
24
25	static function init() {
26	if ( is_null( self::$instance ) ) {
27	self::$instance = new Jetpack_Autoupdate;
28	}
29
30	return self::$instance;
31	}
32
33	private function __construct() {
34	if ( Jetpack::is_module_active( 'manage' ) ) {
35	add_filter( 'auto_update_theme', array( $this, 'autoupdate_theme' ), 10, 2 );
36	add_filter( 'auto_update_core', array( $this, 'autoupdate_core' ), 10, 2 );
37	add_filter( 'auto_update_translation', array( $this, 'autoupdate_translation' ), 10, 2 );
38	add_action( 'automatic_updates_complete', array( $this, 'automatic_updates_complete' ), 999, 1 );
39	}
40	}
41
42	public function autoupdate_translation( $update, $item ) {
43	// Autoupdate all translations
44	if ( Jetpack_Options::get_option( 'autoupdate_translations', false ) ) {
45	return true;
46	}
47
48	// Themes
49	$autoupdate_themes_translations = Jetpack_Options::get_option( 'autoupdate_themes_translations', array() );
50	$autoupdate_theme_list = Jetpack_Options::get_option( 'autoupdate_themes', array() );
51
52	/*
53	$item = {
54	"type":"theme",
55	"slug":"twentyfourteen",
56	"language":"en_CA",
57	"version":"1.8",
58	"updated":"2015-07-18 11:27:20",
59	"package":"https:\/\/downloads.wordpress.org\/translation\/theme\/twentyfourteen\/1.8\/en_CA.zip",
60	"autoupdate":true
61	}
62	*/
63	if ( ( in_array( $item->slug, $autoupdate_themes_translations )
64	\|\| in_array( $item->slug, $autoupdate_theme_list ) )
65	&& 'theme' === $item->type
66	) {
67	$this->expect( $item->type . ':' . $item->slug, 'translation' );
68
69	return true;
70	}
71
72	// Plugins
73	$autoupdate_plugin_translations = Jetpack_Options::get_option( 'autoupdate_plugins_translations', array() );
74	$autoupdate_plugin_list = Jetpack_Options::get_option( 'autoupdate_plugins', array() );
75	$plugin_files = array_unique( array_merge( $autoupdate_plugin_list, $autoupdate_plugin_translations ) );
76	$plugin_slugs = array_map( array( __CLASS__, 'get_plugin_slug' ), $plugin_files );
77
78	if ( in_array( $item->slug, $plugin_slugs )
79	&& 'plugin' === $item->type
80	) {
81	$this->expect( $item->type . ':' . $item->slug, 'translation' );
82	return true;
83	}
84
85	return $update;
86	}
87
88	public function autoupdate_theme( $update, $item ) {
89	$autoupdate_theme_list = Jetpack_Options::get_option( 'autoupdate_themes', array() );
90	if ( in_array( $item->theme, $autoupdate_theme_list ) ) {
91	$this->expect( $item->theme, 'theme' );
92	return true;
93	}
94
95	return $update;
96	}
97
98	public function autoupdate_core( $update, $item ) {
99	$autoupdate_core = Jetpack_Options::get_option( 'autoupdate_core', false );
100	if ( $autoupdate_core ) {
101	return $autoupdate_core;
102	}
103
104	return $update;
105	}
106
107	/**
108	* Stores the an item identifier to the expected array.
109	*
110	* @param string $item Example: 'jetpack/jetpack.php' for type 'plugin' or 'twentyfifteen' for type 'theme'
111	* @param string $type 'plugin' or 'theme'
112	*/
113	private function expect( $item, $type ) {
114	if ( ! isset( $this->expected[ $type ] ) ) {
115	$this->expected[ $type ] = array();
116	}
117	$this->expected[ $type ][] = $item;
118	}
119
120	/**
121	* On completion of an automatic update, let's store the results.
122	*
123	* @param $results - Sent by WP_Automatic_Updater after it completes an autoupdate action. Results may be empty.
124	*/
125	public function automatic_updates_complete( $results ) {
126	if ( empty( $this->expected ) ) {
127	return;
128	}
129	$this->results = empty( $results ) ? self::get_possible_failures() : $results;
130
131	add_action( 'shutdown', array( $this, 'bump_stats' ) );
132
133	Jetpack::init();
134
135	$items_to_log = array( 'plugin', 'theme', 'translation' );
136	foreach ( $items_to_log as $items ) {
137	$this->log_items( $items );
138	}
139
140	Jetpack::log( 'autoupdates', $this->get_log() );
141	}
142
143	public function get_log() {
144	return array(
145	'results' => $this->results,
146	'failed' => $this->failed,
147	'success' => $this->success
148	);
149	}
150
151	/**
152	* Iterates through expected items ( plugins or themes ) and compares them to actual results.
153	*
154	* @param $items 'plugin' or 'theme'
155	*/
156	private function log_items( $items ) {
157	if ( ! isset( $this->expected[ $items ] ) ) {
158	return;
159	}
160
161	$item_results = $this->get_successful_updates( $items );
162
163	if ( is_array( $this->expected[ $items ] ) ) {
164	foreach ( $this->expected[ $items ] as $item ) {
165	if ( in_array( $item, $item_results ) ) {
166	$this->success[ $items ][] = $item;
167	} else {
168	$this->failed[ $items ][] = $item;
169	}
170	}
171	}
172	}
173
174	public function bump_stats() {
175	$instance = Jetpack::init();
176	$log = array();
177	// Bump numbers
178
179	if ( ! empty( $this->success['theme'] ) ) {
180	$instance->stat( 'autoupdates/theme-success', count( $this->success['theme'] ) );
181	$log['themes_success'] = $this->success['theme'];
182	}
183
184	if ( ! empty( $this->failed['theme'] ) ) {
185	$instance->stat( 'autoupdates/theme-fail', count( $this->failed['theme'] ) );
186	$log['themes_failed'] = $this->failed['theme'];
187	}
188
189	$instance->do_stats( 'server_side' );
190
191	// Send a more detailed log to logstash
192	if ( ! empty( $log ) ) {
193	Jetpack::load_xml_rpc_client();
194	$xml = new Jetpack_IXR_Client( array(
195	'user_id' => get_current_user_id()
196	) );
197	$log['blog_id'] = Jetpack_Options::get_option( 'id' );
198	$xml->query( 'jetpack.debug_autoupdate', $log );
199	}
200	}
201
202	/**
203	* Parses the autoupdate results generated by WP_Automatic_Updater and returns a simple array of successful items
204	*
205	* @param string $type 'plugin' or 'theme'
206	*
207	* @return array
208	*/
209	private function get_successful_updates( $type ) {
210	$successful_updates = array();
211
212	if ( ! isset( $this->results[ $type ] ) ) {
213	return $successful_updates;
214	}
215
216	foreach ( $this->results[ $type ] as $result ) {
217	if ( $result->result ) {
218	switch ( $type ) {
219	case 'theme':
220	$successful_updates[] = $result->item->theme;
221	break;
222	case 'translation':
223	$successful_updates[] = $result->item->type . ':' . $result->item->slug;
224	break;
225	}
226	}
227	}
228
229	return $successful_updates;
230	}
231
232	static function get_possible_failures() {
233	$result = array();
234	// Lets check some reasons why it might not be working as expected
235	include_once( ABSPATH . '/wp-admin/includes/admin.php' );
236	include_once( ABSPATH . '/wp-admin/includes/class-wp-upgrader.php' );
237	$upgrader = new WP_Automatic_Updater;
238
239	if ( $upgrader->is_disabled() ) {
240	$result[] = 'autoupdates-disabled';
241	}
242	if ( ! is_main_site() ) {
243	$result[] = 'is-not-main-site';
244	}
245	if ( ! is_main_network() ) {
246	$result[] = 'is-not-main-network';
247	}
248	if ( $upgrader->is_vcs_checkout( ABSPATH ) ) {
249	$result[] = 'site-on-vcs';
250	}
251	if ( $upgrader->is_vcs_checkout( WP_PLUGIN_DIR ) ) {
252	$result[] = 'plugin-directory-on-vcs';
253	}
254	if ( $upgrader->is_vcs_checkout( WP_CONTENT_DIR ) ) {
255	$result[] = 'content-directory-on-vcs';
256	}
257	$lock = get_option( 'auto_updater.lock' );
258	if ( $lock > ( time() - HOUR_IN_SECONDS ) ) {
259	$result[] = 'lock-is-set';
260	}
261	$skin = new Automatic_Upgrader_Skin;
262	include_once( ABSPATH . 'wp-admin/includes/file.php' );
263	include_once( ABSPATH . 'wp-admin/includes/template.php' );
264	if ( ! $skin->request_filesystem_credentials( false, ABSPATH, false ) ) {
265	$result[] = 'no-system-write-access';
266	}
267	if ( ! $skin->request_filesystem_credentials( false, WP_PLUGIN_DIR, false ) ) {
268	$result[] = 'no-plugin-directory-write-access';
269	}
270	if ( ! $skin->request_filesystem_credentials( false, WP_CONTENT_DIR, false ) ) {
271	$result[] = 'no-wp-content-directory-write-access';
272	}
273
274	return $result;
275	}
276
277	static function get_plugin_slug( $plugin_file ) {
278	$update_plugins = get_site_transient( 'update_plugins' );
279	if ( isset( $update_plugins->no_update ) ) {
280	if ( isset( $update_plugins->no_update[ $plugin_file ] ) ) {
281	$slug = $update_plugins->no_update[ $plugin_file ]->slug;
282	}
283	}
284	if ( empty( $slug ) && isset( $update_plugins->response ) ) {
285	if ( isset( $update_plugins->response[ $plugin_file ] ) ) {
286	$slug = $update_plugins->response[ $plugin_file ]->slug;
287	}
288	}
289
290	// Try to infer from the plugin file if not cached
291	if ( empty( $slug) ) {
292	$slug = dirname( $plugin_file );
293	if ( '.' === $slug ) {
294	$slug = preg_replace("/(.+)\.php$/", "$1", $plugin_file );
295	}
296	}
297	return $slug;
298	}
299
300	}
301
302	Jetpack_Autoupdate::init();
303