def run(self): alerts = [] try: update = Update.objects.order_by('-id')[0] except IndexError: update = Update.objects.create() path = notifier().system_dataset_path() if not path: return None try: check = CheckForUpdates(train=update.get_train(), cache_dir=path) except: check = None if check: alerts.append( Alert( Alert.OK, _( 'There is a new update available! Apply it in System ' '-> Update tab.' ), ) ) return alerts
def check_available(self, attrs=None): """ Checks if there is an update available from update server. status: - REBOOT_REQUIRED: an update has already been applied - AVAILABLE: an update is available - UNAVAILABLE: no update available .. examples(websocket):: Check available update using default train: :::javascript { "id": "6841f242-840a-11e6-a437-00e04d680384", "msg": "method", "method": "update.check_available" } """ try: applied = self.middleware.call_sync('cache.get', 'update.applied') except Exception: applied = False if applied is True: return {'status': 'REBOOT_REQUIRED'} train = (attrs or {}).get('train') or self.middleware.call_sync( 'update.get_trains')['selected'] handler = CheckUpdateHandler() manifest = CheckForUpdates( diff_handler=handler.diff_call, handler=handler.call, train=train, ) if not manifest: return {'status': 'UNAVAILABLE'} data = { 'status': 'AVAILABLE', 'changes': handler.changes, 'notice': manifest.Notice(), 'notes': manifest.Notes(), } conf = Configuration.Configuration() sys_mani = conf.SystemManifest() if sys_mani: sequence = sys_mani.Sequence() else: sequence = '' data['changelog'] = get_changelog(train, start=sequence, end=manifest.Sequence()) data['version'] = manifest.Version() return data
def check_train(self, train): handler = CheckUpdateHandler() manifest = CheckForUpdates( diff_handler=handler.diff_call, handler=handler.call, train=train, ) if not manifest: return {'status': 'UNAVAILABLE'} data = { 'status': 'AVAILABLE', 'changes': handler.changes, 'notice': manifest.Notice(), 'notes': manifest.Notes(), } conf = Configuration.Configuration() sys_mani = conf.SystemManifest() if sys_mani: sequence = sys_mani.Sequence() else: sequence = '' data['changelog'] = get_changelog(train, start=sequence, end=manifest.Sequence()) data['version'] = manifest.Version() return data
def check_updates(dispatcher, configstore, cache_dir=None, check_now=False): "Utility function to just check for Updates" update_cache.invalidate('updateAvailable') update_cache.invalidate('updateNotes') update_cache.invalidate('updateNotice') update_cache.invalidate('updateOperations') update_cache.invalidate('changelog') conf = Configuration.Configuration() update_ops = None handler = CheckUpdateHandler() train = configstore.get('update.train') notes = None notice = None try: update = CheckForUpdates( handler=handler.call, train=train, cache_dir=None if check_now else cache_dir, ) except Exception: update_cache.put('updateAvailable', False) update_cache.put('updateNotes', None) update_cache.put('updateNotice', None) update_cache.put('updateOperations', update_ops) update_cache.put('changelog', '') raise if update: logger.debug("An update is available") update_ops = handler.output() sys_mani = conf.SystemManifest() if sys_mani: sequence = sys_mani.Sequence() else: sequence = '' changelog = get_changelog(train, cache_dir=cache_dir, start=sequence, end=update.Sequence()) notes = update.Notes() notice = update.Notice() else: logger.debug("No update available") changelog = None update_cache.put('updateAvailable', True if update else False) update_cache.put('updateOperations', update_ops) update_cache.put('changelog', changelog) update_cache.put('updateNotes', notes) update_cache.put('updateNotice', notice)
def check_train(self, train): if 'SCALE' in train: old_version = self.middleware.call_sync('system.version').split( '-', 1)[1] return self.middleware.call_sync('update.get_scale_update', train, old_version) handler = CheckUpdateHandler() manifest = CheckForUpdates( diff_handler=handler.diff_call, handler=handler.call, train=train, ) if not manifest: return {'status': 'UNAVAILABLE'} data = { 'status': 'AVAILABLE', 'changes': handler.changes, 'notice': manifest.Notice(), 'notes': manifest.Notes(), } conf = Configuration.Configuration() sys_mani = conf.SystemManifest() if sys_mani: sequence = sys_mani.Sequence() else: sequence = '' data['changelog'] = get_changelog(train, start=sequence, end=manifest.Sequence()) data['version'] = manifest.Version() return data
def check_available(self, attrs=None): """ Checks if there is an update available from update server. status: - REBOOT_REQUIRED: an update has already been applied - AVAILABLE: an update is available - UNAVAILABLE: no update available .. examples(websocket):: Check available update using default train: :::javascript { "id": "6841f242-840a-11e6-a437-00e04d680384", "msg": "method", "method": "update.check_available" } """ try: applied = self.middleware.call_sync('cache.get', 'update.applied') except Exception: applied = False if applied is True: return {'status': 'REBOOT_REQUIRED'} if (not self.middleware.call_sync('system.is_freenas') and self.middleware.call_sync('failover.licensed')): # If its HA and standby is running old version we assume # legacy upgrade and check update on standby. try: self.middleware.call_sync( 'failover.call_remote', 'failover.upgrade_version', ) except CallError as e: if e.errno != CallError.ENOMETHOD: raise return self.middleware.call_sync( 'failover.call_remote', 'update.check_available', [attrs], ) trains = self.middleware.call_sync('update.get_trains') train = (attrs or {}).get('train') if not train: train = trains['selected'] elif train not in trains['trains']: raise CallError('Invalid train name.', errno.ENOENT) handler = CheckUpdateHandler() manifest = CheckForUpdates( diff_handler=handler.diff_call, handler=handler.call, train=train, ) if not manifest: return {'status': 'UNAVAILABLE'} data = { 'status': 'AVAILABLE', 'changes': handler.changes, 'notice': manifest.Notice(), 'notes': manifest.Notes(), } conf = Configuration.Configuration() sys_mani = conf.SystemManifest() if sys_mani: sequence = sys_mani.Sequence() else: sequence = '' data['changelog'] = get_changelog(train, start=sequence, end=manifest.Sequence()) data['version'] = manifest.Version() return data
def check_updates(dispatcher, configstore, cache_dir=None, check_now=False): """ Utility function to just check for Updates """ update_cache_value_dict = default_update_dict.copy() # If the current check is an online one (and not in the cache_dir) # then store the current update info and use them to restore the update cache # if the update check fails, this way a downloaded update is not lost from # the cache if a live online one fails! current_update_info = None try: current_update_info = dispatcher.call_sync('update.update_info') except RpcException: pass if current_update_info: update_cache_value_dict['installed'] = current_update_info.get( 'installed') update_cache_value_dict['installed_version'] = current_update_info.get( 'installed_version') if check_now and current_update_info['downloaded']: update_cache_value_dict.update(current_update_info.copy()) update_cache_value_dict['available'] = True dispatcher.call_sync('update.update_cache_invalidate', list(update_cache_value_dict.keys())) conf = Configuration.Configuration() handler = CheckUpdateHandler() train = configstore.get('update.train') try: update = CheckForUpdates( handler=handler.call, train=train, cache_dir=None if check_now else cache_dir, ) if update: version = update.Version() update_installed_bootenv = list( is_update_applied(dispatcher, version)) if version == update_cache_value_dict[ 'installed_version'] or update_installed_bootenv: logger.debug('Update is already installed') update_cache_value_dict = default_update_dict.copy() update_cache_value_dict.update({ 'installed': True, 'installed_version': version }) dispatcher.call_sync( 'update.update_alert_set', 'UpdateInstalled', version, {'update_installed_bootenv': update_installed_bootenv}) return logger.debug("An update is available") sys_mani = conf.SystemManifest() if sys_mani: sequence = sys_mani.Sequence() else: sequence = '' try: if check_now: changelog = get_changelog(train, cache_dir=cache_dir, start=sequence, end=update.Sequence()) else: changelog_file = "{0}/ChangeLog.txt".format(cache_dir) changelog = parse_changelog(changelog_file.read(), start=sequence, end=update.Sequence()) except Exception: changelog = '' update_cache_value_dict.update({ 'available': True, 'notes': update.Notes(), 'notice': update.Notice(), 'operations': handler.output(), 'version': version, 'changelog': changelog, 'downloaded': False if check_now else True }) dispatcher.call_sync( 'update.update_alert_set', 'UpdateDownloaded' if update_cache_value_dict['downloaded'] else 'UpdateAvailable', update_cache_value_dict['version']) else: logger.debug('No update available') finally: dispatcher.call_sync('update.update_cache_putter', update_cache_value_dict)
def main(): def usage(): print >> sys.stderr, "Usage: %s [-R root] [-M manifest_file] <cmd>, where cmd is one of:" % sys.argv[ 0] print >> sys.stderr, "\tcheck\tCheck for updates" print >> sys.stderr, "\tupdate\tDo an update" print >> sys.stderr, "\tinstall\tInstall" sys.exit(1) try: opts, args = getopt.getopt(sys.argv[1:], "qvdR:M:T:") except getopt.GetoptError as err: print str(err) usage() root = None manifile = None verbose = 0 debug = 0 tmpdir = None config_file = None config = None for o, a in opts: if o == "-v": verbose += 1 elif o == "-q": quiet = True elif o == "-d": debug += 1 elif o == "-R": root = a elif o == "-M": manifile = a elif o == '-C': config_file = a elif o == "-T": tmpdir = a else: assert False, "unhandled option" logging.config.dictConfig({ 'version': 1, 'disable_existing_loggers': True, 'formatters': { 'simple': { 'format': '[%(name)s:%(lineno)s] %(message)s', }, }, 'handlers': { 'std': { 'class': 'logging.StreamHandler', 'level': 'DEBUG', 'stream': 'ext://sys.stdout', }, }, 'loggers': { '': { 'handlers': ['std'], 'level': 'DEBUG', 'propagate': True, }, }, }) sys.path.append("/usr/local/lib") import freenasOS.Configuration as Configuration from freenasOS.Update import CheckForUpdates, Update if root is not None and os.path.isdir(root) is False: print >> sys.stderr, "Specified root (%s) does not exist" % root sys.exit(1) if config_file is not None: # We want the system configuration file config = Configuration.Configuration(file=config_file, root=None) if len(args) != 1: usage() if args[0] == "check": def Handler(op, pkg, old): if op == "upgrade": print "%s: %s -> %s" % (pkg.Name(), old.Version(), pkg.Version()) else: print "%s: %s %s" % (pkg.Name(), op, pkg.Version()) if verbose > 0 or debug > 0: pfcn = Handler else: pfcn = None try: update = CheckForUpdates(root, pfcn) except ValueError: print >> sys.stderr, "No manifest found" return 1 if update is not None: print >> sys.stderr, "Newer manifest found" return 0 else: print >> sys.stderr, "No newer manifest found" return 1 elif args[0] == "update": r = Update(root, config) if r: return 0 else: return 1 else: usage()
handler.finished = True handler.dump() os.kill(handler.pid, 9) else: if handler.error is not False: raise MiddlewareError(handler.error) if not handler.finished: return HttpResponse(handler.uuid, status=202) handler.exit() request.session['allow_reboot'] = True return render(request, 'system/done.html') else: handler = CheckUpdateHandler() try: update = CheckForUpdates( handler=handler.call, train=updateobj.get_train(), ) except: update = None return render(request, 'system/update.html', { 'update': update, 'handler': handler, }) def update_check(request): try: updateobj = models.Update.objects.order_by('-id')[0] except IndexError: updateobj = models.Update.objects.create()
def check_updates(dispatcher, configstore, cache_dir=None, check_now=False): """ Utility function to just check for Updates """ update_cache_value_dict = default_update_dict.copy() # If the current check is an online one (and not in the cache_dir) # then store the current update info and use them to restore the update cache # if the update check fails, this way a downloaded update is not lost from # the cache if a live online one fails! current_update_info = None try: current_update_info = dispatcher.call_sync('update.update_info') if (current_update_info.get('installed') and is_update_applied( dispatcher, current_update_info.get('installed_version'))): update_cache_value_dict.update({ 'installed': True, 'installed_version': current_update_info.get('installed_version') }) if check_now and current_update_info['downloaded']: update_cache_value_dict.update(current_update_info.copy()) update_cache_value_dict['available'] = True except RpcException: pass logger.trace('check_updates: this is the current_update_info: {0}'.format( current_update_info)) dispatcher.call_sync('update.update_cache_invalidate', list(update_cache_value_dict.keys())) conf = Configuration.Configuration() handler = CheckUpdateHandler() train = configstore.get('update.train') logger.trace('check_updates: Update server name: {0}, url: {1}'.format( conf.UpdateServerName(), conf.UpdateServerURL())) try: update = CheckForUpdates( handler=handler.call, train=train, cache_dir=None if check_now else cache_dir, ) if update: version = update.Version() update_installed_bootenv = is_update_applied(dispatcher, version) sys_mani = conf.SystemManifest() sequence = sys_mani.Sequence() if sys_mani else '' if version == update_cache_value_dict[ 'installed_version'] or update_installed_bootenv: if update_installed_bootenv and update_installed_bootenv[ 'active']: # it could be possible that the installed os has the same version as # the one available from the server and yet the one on the server has # something new to offer, hence check for seequence numbers to rule out # all doubt if update.Sequence() == sequence: logger.debug( 'Update has same sequence number as current OS') # At this point clear any installed version stuff update_cache_value_dict.update({ 'installed': False, 'installed_version': '' }) else: logger.debug( 'Update has same version but different sequence number as current OS' ) else: # TODO: mount the BE in question to inspect sequence number logger.debug( 'Update version {0} is already installed in BE {1}'. format(version, update_installed_bootenv)) update_cache_value_dict = default_update_dict.copy() update_cache_value_dict.update({ 'installed': True, 'installed_version': version }) dispatcher.call_sync( 'update.update_alert_set', 'UpdateInstalled', version, {'update_installed_bootenv': update_installed_bootenv}) else: logger.debug('Update {0} is available'.format(version)) try: if check_now: changelog = get_changelog(train, cache_dir=cache_dir, start=sequence, end=update.Sequence()) else: with open("{0}/ChangeLog.txt".format(cache_dir), 'r') as changelog_file: changelog = parse_changelog(changelog_file.read(), start=sequence, end=update.Sequence()) except Exception: changelog = '' update_cache_value_dict.update({ 'available': True, 'notes': update.Notes(), 'notice': update.Notice(), 'operations': handler.output(), 'version': version, 'changelog': changelog, 'downloaded': False if check_now else True }) dispatcher.call_sync( 'update.update_alert_set', 'UpdateDownloaded' if update_cache_value_dict['downloaded'] else 'UpdateAvailable', update_cache_value_dict['version']) else: logger.debug('No update available') finally: dispatcher.call_sync('update.update_cache_putter', update_cache_value_dict)
handler.error = unicode(e) handler.finished = True handler.dump() os.kill(handler.pid, 9) else: if handler.error is not False: raise MiddlewareError(handler.error) if not handler.finished: return HttpResponse(handler.uuid, status=202) handler.exit() request.session['allow_reboot'] = True return render(request, 'system/done.html') handler = CheckUpdateHandler() try: update = CheckForUpdates(handler=handler.call) except ValueError: update = False return render(request, 'system/upgrade.html', { 'update': update, 'handler': handler, }) def upgrade_progress(request): handler = UpdateHandler() return HttpResponse( json.dumps(handler.load()), content_type='application/json', )