1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2013-2014 Team-XBMC
Copyright (C) 2014-2019 Team Kodi
This file is part of service.xbmc.versioncheck
SPDX-License-Identifier: GPL-3.0-or-later
See LICENSES/GPL-3.0-or-later.txt for more information.
"""
from .common import log
def compare_version(version_installed, version_list):
""" Compare the installed version against the provided version list
:param version_installed: currently installed version
:type version_installed: dict
:param version_list: provided versions to compare against
:type version_list: dict
:return: old, current, available, and stable versions
:rtype: bool / 'stable', dict, dict, dict
"""
# Create separate version lists
version_list_stable = version_list['releases']['stable']
version_list_rc = version_list['releases']['releasecandidate']
version_list_beta = version_list['releases']['beta']
version_list_alpha = version_list['releases']['alpha']
# version_list_prealpha = version_list['releases']['prealpha']
stable_version = version_list_stable[0]
rc_version = version_list_rc[0]
beta_version = version_list_beta[0]
alpha_version = version_list_alpha[0]
log('Version installed %s' % version_installed)
# Check to upgrade to newest available stable version
# check on smaller major version. Smaller version than available always notify
# check for stable versions
old_version, version_available = _check_for_stable_version(version_installed, stable_version)
if not old_version:
# Already skipped a possible newer stable build. Let's continue with non stable builds.
# Check also 'old version' hasn't been set to 'stable' or true by previous checks because
# if so, those part need to be skipped
old_version, version_available = _check_for_rc_version(version_installed,
rc_version, beta_version)
if not old_version:
# check for beta builds
old_version, version_available = _check_for_beta_version(version_installed, beta_version)
if not old_version:
# check for alpha builds
old_version, version_available = _check_for_alpha_version(version_installed, alpha_version)
return old_version, version_installed, version_available, stable_version
def _check_for_stable_version(version_installed, stable_version):
""" Compare the installed version against the latest stable version
:param version_installed: currently installed version
:type version_installed: dict
:param stable_version: latest stable version
:type stable_version: dict
:return: whether using an old version, and available version if newer stable version available
:rtype: bool / 'stable', dict
"""
# check if installed major version is smaller than available major stable
# here we don't care if running non stable
old_version = False
version_available = {}
if version_installed['major'] < int(stable_version['major']):
version_available = stable_version
old_version = 'stable'
log('Version available %s' % stable_version)
log('You are running an older version')
# check if installed major version is equal than available major stable
# however also check on minor version and still don't care about non stable
elif version_installed['major'] == int(stable_version['major']):
if version_installed['minor'] < int(stable_version['minor']):
version_available = stable_version
old_version = 'stable'
log('Version available %s' % stable_version)
log('You are running an older minor version')
# check for <= minor !stable
elif version_installed['tag'] != 'stable' and \
version_installed['minor'] <= int(stable_version['minor']):
version_available = stable_version
old_version = True
log('Version available %s' % stable_version)
log('You are running an older non stable minor version')
else:
log('Version available %s' % stable_version)
log('There is no newer stable available')
return old_version, version_available
def _check_for_rc_version(version_installed, rc_version, beta_version):
""" Compare the installed version against the latest RC version
:param version_installed: currently installed version
:type version_installed: dict
:param rc_version: latest rc version
:type rc_version: dict
:param beta_version: latest beta version
:type beta_version: dict
:return: whether using an old version, and available version if newer rc version available
:rtype: bool, dict
"""
old_version = False
version_available = {}
# check for RC builds
if version_installed['tag'] in ['releasecandidate']:
# check if you are using a RC build lower than current available RC
# then check if you are using a beta/alpha lower than current available RC
# 14.0rc3 is newer than: 14.0rc1, 14.0b9, 14.0a15
if version_installed['major'] <= int(rc_version['major']):
if version_installed['minor'] <= int(rc_version['minor']):
if version_installed.get('tagversion', '') < rc_version['tagversion']:
version_available = rc_version
old_version = True
log('Version available %s' % rc_version)
log('You are running an older RC version')
# now check if installed !=rc
elif version_installed['tag'] in ['beta', 'alpha', 'prealpha']:
if version_installed['major'] <= int(rc_version['major']):
if version_installed['minor'] <= int(beta_version['minor']):
version_available = rc_version
old_version = True
log('Version available %s' % rc_version)
log('You are running an older non RC version')
return old_version, version_available
def _check_for_beta_version(version_installed, beta_version):
""" Compare the installed version against the latest beta version
:param version_installed: currently installed version
:type version_installed: dict
:param beta_version: latest beta version
:type beta_version: dict
:return: whether using an old version, and available version if newer beta version available
:rtype: bool, dict
"""
old_version = False
version_available = {}
# check for beta builds
if not old_version and version_installed['tag'] == 'beta':
# check if you are using a RC build lower than current available RC
# then check if you are using a beta/alpha lower than current available RC
# 14.0b3 is newer than: 14.0b1, 14.0a15
if version_installed['major'] <= int(beta_version['major']):
if version_installed['minor'] <= int(beta_version['minor']):
if version_installed.get('tagversion', '') < beta_version['tagversion']:
version_available = beta_version
old_version = True
log('Version available %s' % beta_version)
log('You are running an older beta version')
# now check if installed !=beta
elif not old_version and version_installed['tag'] in ['alpha', 'prealpha']:
if version_installed['major'] <= int(beta_version['major']):
if version_installed['minor'] <= int(beta_version['minor']):
version_available = beta_version
old_version = True
log('Version available %s' % beta_version)
log('You are running an older non beta version')
return old_version, version_available
def _check_for_alpha_version(version_installed, alpha_version):
""" Compare the installed version against the latest alpha version
:param version_installed: currently installed version
:type version_installed: dict
:param alpha_version: latest alpha version
:type alpha_version: dict
:return: whether using an old version, and available version if newer alpha version available
:rtype: bool, dict
"""
old_version = False
version_available = {}
# check for alpha builds and older
if version_installed['tag'] == 'alpha':
# check if you are using a RC build lower than current available RC
# then check if you are using a beta/alpha lower than current available RC
# 14.0a3 is newer than: 14.0a1 or pre-alpha
if version_installed['major'] <= int(alpha_version['major']):
if version_installed['minor'] <= int(alpha_version['minor']):
if version_installed.get('tagversion', '') < alpha_version['tagversion']:
version_available = alpha_version
old_version = True
log('Version available %s' % alpha_version)
log('You are running an older alpha version')
# now check if installed !=alpha
elif version_installed['tag'] in ['prealpha']:
if version_installed['major'] <= int(alpha_version['major']):
if version_installed['minor'] <= int(alpha_version['minor']):
version_available = alpha_version
old_version = True
log('Version available %s' % alpha_version)
log('You are running an older non alpha version')
return old_version, version_available
|
