Exemple #1
0
def check_internet():
    if is_internet():
        return True

    logger.warn("No internet connection detected")
    os.system("kano-settings 12")
    return is_internet()
Exemple #2
0
def check_internet():
    if is_internet():
        return True

    logger.warn("No internet connection detected")
    os.system("kano-settings 12")
    return is_internet()
Exemple #3
0
def share(filename):
    # TODO: Move this connection handling into a function in Kano Utils
    import subprocess

    if not is_internet():
        subprocess.call(['sudo', 'kano-settings', '4'])

    if not is_internet():
        return 'You have no internet'

    success, _ = login_using_token()
    if not success:
        os.system('kano-login 3')
        success, _ = login_using_token()
        if not success:
            return 'Cannot login'

    data = json.loads(request.data)
    filename, filepath = _save(data)
    success, msg = upload_share(filepath, filename, APP_NAME)

    if not success:
        return msg

    increment_app_state_variable_with_dialog(APP_NAME, 'shared', 1)

    return ''
Exemple #4
0
def share(filename):
    # TODO: Move this connection handling into a function in Kano Utils
    import subprocess

    if not is_internet():
        subprocess.call(['sudo', 'kano-settings', '4'])

    if not is_internet():
        return 'You have no internet'

    success, _ = login_using_token()
    if not success:
        os.system('kano-login 3')
        success, _ = login_using_token()
        if not success:
            return 'Cannot login'

    data = json.loads(request.data)
    filename, filepath = _save(data)
    success, msg = upload_share(filepath, filename, APP_NAME)

    if not success:
        return msg

    increment_app_state_variable_with_dialog(APP_NAME, 'shared', 1)

    return ''
Exemple #5
0
def try_connect():
    '''
    Returns internet status.
    If connection fails the first time, the WiFi config will be launched
    '''
    if is_internet():
        return True

    run_cmd('sudo /usr/bin/kano-settings 12', localised=True)

    return is_internet()
def try_connect():
    '''
    Returns internet status.
    If connection fails the first time, the WiFi config will be launched
    '''
    if is_internet():
        return True

    run_cmd('sudo /usr/bin/kano-settings 12', localised=True)

    return is_internet()
Exemple #7
0
def ensure_internet():
    """Ensure there is an internet connection.

    Check for an internet connection and uses ``kano-settings`` to configure
    one if not setup. If the popup subsequently fails, the operation quits.

    Returns:
        bool: Whether there is an internet connection
    """

    if not is_internet():
        run_cmd('sudo kano-settings --label no-internet', localised=True)
        return is_internet()

    return True
        def _launch_application(self, widget=None):
            # Decide whether application prompts user to plug in WiFi dongle
            # or tell them they have ethernet.
            # Don't want to call this function more than once
            self.wiface = get_wlan_device()

            has_internet = is_internet()
            ethernet_plugged = is_ethernet_plugged()
            dongle_is_plugged_in = is_device(self.wiface)

            if has_internet and ethernet_plugged and self.no_confirm_ether:
                sys.exit(0)

            # For testing
            # dongle_is_plugged_in = False
            # ethernet_plugged = True
            # has_internet = False

            if has_internet and ethernet_plugged:
                self._you_are_connected_via_ethernet()

            elif dongle_is_plugged_in:
                if has_internet:
                    self._you_have_internet_screen(self.wiface)
                else:
                    # Refresh the networks list
                    self.refresh_networks()

            else:
                self._plug_in_wifi_dongle()
    def login_screen(self, widget, event):
        self.win.remove_main_widget()

        if is_internet():
            Login(win=self.win, prev_screen=None, first_boot=True)
        else:
            NoInternet(self.win)
Exemple #10
0
    def first_scene(self):
        if is_internet():
            self._ctl.next_stage()
            return

        s1 = self._setup_first_scene()
        self._ctl.main_window.push(s1)
Exemple #11
0
def install_pip_packages(progress, priority=Priority.NONE):
    # Urgent updates don't do PIP updates
    if priority == Priority.URGENT:
        return

    phase_name = progress.get_current_phase().name

    packages = read_file_contents_as_lines(PIP_PACKAGES_LIST)
    progress.init_steps(phase_name, len(packages))

    for pkg in packages:
        progress.next_step(phase_name, "Installing {}".format(pkg))

        success = run_pip_command(
            "install --upgrade --no-index --find-links=file://{} '{}'".format(
                PIP_CACHE_DIR, pkg)
        )

        if not success:
            msg = "Installing the '{}' pip package failed".format(pkg)
            logger.error(msg)
            if not is_internet():
                msg = "Network is down, aborting PIP install"
                logger.error(msg)
                raise IOError(msg)

            # Try with the failsafe method
            success_failsafe = run_pip_command(
                "install --upgrade '{}'".format(pkg)
            )
            if not success_failsafe:
                msg = "Installing the '{}' pip package failed (fsafe)".format(
                    pkg)
                logger.error(msg)
Exemple #12
0
def install_pip_packages(progress, priority=Priority.NONE):
    # Urgent updates don't do PIP updates
    if priority == Priority.URGENT:
        return

    phase_name = progress.get_current_phase().name

    packages = read_file_contents_as_lines(PIP_PACKAGES_LIST)
    progress.init_steps(phase_name, len(packages))

    for pkg in packages:
        progress.next_step(phase_name, "Installing {}".format(pkg))

        success = run_pip_command(
            "install --upgrade --no-index --find-links=file://{} '{}'".format(
                PIP_CACHE_DIR, pkg))

        if not success:
            msg = "Installing the '{}' pip package failed".format(pkg)
            logger.error(msg)
            if not is_internet():
                msg = "Network is down, aborting PIP install"
                logger.error(msg)
                raise IOError(msg)

            # Try with the failsafe method
            success_failsafe = run_pip_command(
                "install --upgrade '{}'".format(pkg))
            if not success_failsafe:
                msg = "Installing the '{}' pip package failed (fsafe)".format(
                    pkg)
                logger.error(msg)
Exemple #13
0
    def login_screen(self, widget, event):
        self.win.remove_main_widget()

        if is_internet():
            Login(win=self.win, prev_screen=None, first_boot=True)
        else:
            NoInternet(self.win)
        def _launch_application(self, widget=None):
            # Decide whether application prompts user to plug in WiFi dongle
            # or tell them they have ethernet.
            # Don't want to call this function more than once
            self.wiface = get_wlan_device()

            has_internet = is_internet()
            ethernet_plugged = is_ethernet_plugged()
            dongle_is_plugged_in = is_device(self.wiface)

            if has_internet and ethernet_plugged and self.no_confirm_ether:
                sys.exit(0)

            # For testing
            # dongle_is_plugged_in = False
            # ethernet_plugged = True
            # has_internet = False

            if has_internet and ethernet_plugged:
                self._you_are_connected_via_ethernet()

            elif dongle_is_plugged_in:
                if has_internet:
                    self._you_have_internet_screen(self.wiface)
                else:
                    # Refresh the networks list
                    self.refresh_networks()

            else:
                self._plug_in_wifi_dongle()
Exemple #15
0
    def first_scene(self):
        if not is_internet():
            self.next_stage()
            return

        s = self._setup_first_scene()
        self._ctl.main_window.push(s)
Exemple #16
0
    def switch_to_home(self):
        self.prev_view = []

        if is_internet():
            self.view = HomeView()
            self.contents.set_contents(self.view)
        else:
            self.switch_view('no-internet')
    def switch_to_home(self):
        self.prev_view = []

        if is_internet():
            self.view = HomeView()
            self.contents.set_contents(self.view)
        else:
            self.switch_view('no-internet')
Exemple #18
0
    def first_scene(self):

        if is_internet():
            self._ctl.set_var("has_internet", True)
            self._ctl.next_stage()
            return

        s = self._setup_first_scene()
        self._ctl.main_window.push(s)
    def login_screen(self, widget, event):
        self.win.remove_main_widget()

        if is_internet():
            # Hand-off from the Gtk to the web view
            Gtk.main_quit()
            os.system('{} {} {}'.format(FirstScreen.webengine, AUTH_URL, FirstScreen.win_size))
        else:
            NoInternet(self.win)
    def login_screen(self, widget, event):
        self.win.remove_main_widget()

        if is_internet():
            # Hand-off from the Gtk to the web view
            Gtk.main_quit()
            os.system('{} {} {}'.format(FirstScreen.webengine, AUTH_URL,
                                        FirstScreen.win_size))
        else:
            NoInternet(self.win)
Exemple #21
0
    def second_scene(self):
        # TODO: uncomment before release
        # Jump directly at the end if we have internet
        if is_internet():
            track_action('init-flow-connected-already')
            self.connected_scene()
            return

        s2 = self._setup_second_scene()
        self._ctl.main_window.push(s2)
Exemple #22
0
def share_theme():
    # Check for internet
    if not is_internet():
        coloured_error, junk1, junk2 = run_cmd(
            'colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip('\n') + _(
            'You need internet connection')
        exit(2)
    # Check for login
    success, junk2 = login_using_token()
    if not success:
        coloured_error, junk1, junk2 = run_cmd(
            'colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip('\n') + _(
            'You need to login to Kano World')
        exit(2)
    # Print themes
    print_themes(False, False)
    # Select theme dialogue
    message = _("    1) Select a theme: ")
    theme = raw_input(message)
    theme += '.xml'
    # Check theme exists
    check_valid_theme(theme)
    # Select title
    message = _("    2) Write a title: ")
    title = raw_input(message)
    if title:
        # The API limits title to 200 characters (cut it here)
        title = title[:200]
    else:
        title = 'My snake'
    # Select description
    message = _("    3) Write a description: ")
    description = raw_input(message)
    if description:
        # The API limits description to 500 characters (cut it here)
        description = description[:500]
    # Create json
    create_share_json(theme, title, description)
    # Share
    filepath = os.path.join(app_dir, theme)
    success, msg = upload_share(filepath, title, 'make-snake')
    if not success:
        coloured_error, junk1, junk2 = run_cmd(
            'colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip(
            '\n') + _('Sharing of {} failed. {}\n') % (theme, msg)
        exit(2)
    message, junk1, junk2 = run_cmd(
        'colour_echo "{{4 + }} {{3 You have shared your theme successfully }}"'
    )
    print "\n    " + message.strip('\n')
    increment_app_state_variable_with_dialog('make-snake', 'shared', 1)
    exit(2)
Exemple #23
0
def share(filename):
    # TODO: Move this connection handling into a function in Kano Utils
    import subprocess

    if not is_internet():
        subprocess.call(["sudo", "kano-settings", "4"])

    if not is_internet():
        return "You have no internet"

    data = json.loads(request.data)
    filename, filepath = _save(data)
    success, msg = login_and_share(filepath, filename, APP_NAME)

    if not success:
        return msg

    increment_app_state_variable_with_dialog(APP_NAME, "shared", 1)

    return ""
Exemple #24
0
    def log_user_in(self):
        if not is_internet():
            title = _("You don't have internet!")
            description = _("Connect with wifi or ethernet and try again")
            return_value = 0

        else:
            (title, description,
             return_value) = self.log_user_in_with_internet()

        GObject.idle_add(self.show_login_status_dialog, title, description,
                         return_value)
    def activate(self, _, event):
        """ Move to the first setup screen """

        if not hasattr(event, 'keyval') or event.keyval == 65293:
            self.win.clear_win()

            if not detect_kano_keyboard():
                KeyboardScreen(self.win)
            elif not is_internet():
                InternetScreen(self.win)
            else:
                SettingsIntroScreen(self.win)
Exemple #26
0
    def log_user_in(self):
        if not is_internet():
            title = _("You don't have internet!")
            description = _(
                "Connect with wifi or ethernet and try again"
            )
            return_value = 0

        else:
            (title, description, return_value) = self.log_user_in_with_internet()

        GObject.idle_add(self.show_login_status_dialog,
                         title, description, return_value)
Exemple #27
0
    def switch_to_youtube(self, search_keyword=None, users=False, page=1):
        if is_internet():
            cursor = Gdk.Cursor.new(Gdk.CursorType.WATCH)
            self.get_root_window().set_cursor(cursor)

            Gtk.main_iteration_do(True)

            self.prev_view = []

            self.view = YoutubeView(search_keyword, users, page=page)
            self.contents.set_contents(self.view)

            cursor = Gdk.Cursor.new(Gdk.CursorType.ARROW)
            self.get_root_window().set_cursor(cursor)
        else:
            self.switch_view('no-internet')
    def switch_to_youtube(self, search_keyword=None, users=False, page=1):
        if is_internet():
            cursor = Gdk.Cursor.new(Gdk.CursorType.WATCH)
            self.get_root_window().set_cursor(cursor)

            Gtk.main_iteration_do(True)

            self.prev_view = []

            self.view = YoutubeView(search_keyword, users, page=page)
            self.contents.set_contents(self.view)

            cursor = Gdk.Cursor.new(Gdk.CursorType.ARROW)
            self.get_root_window().set_cursor(cursor)
        else:
            self.switch_view('no-internet')
Exemple #29
0
def share_theme():
    # Check for internet
    if not is_internet():
        coloured_error, _, _ = run_cmd('colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip(
            '\n') + 'You need internet connection'
        exit(2)
    # Check for login
    success, _ = login_using_token()
    if not success:
        coloured_error, _, _ = run_cmd('colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip(
            '\n') + 'You need to login to Kano World'
        exit(2)
    # Print themes
    print_themes(False, False)
    # Select theme dialogue
    message = "    1) Select a theme: "
    theme = raw_input(message)
    theme += '.xml'
    # Check theme exists
    check_valid_theme(theme)
    # Select title
    message = "    2) Write a title: "
    title = raw_input(message)
    if not title:
        title = 'My snake'
    # Select description
    message = "    3) Write a description: "
    description = raw_input(message)
    # Create json
    create_share_json(theme, title, description)
    # Share
    filepath = os.path.join(app_dir, theme)
    success, msg = upload_share(filepath, title, 'make-snake')
    if not success:
        coloured_error, _, _ = run_cmd('colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip(
            '\n') + 'Sharing of %s failed. %s\n' % (theme, msg)
        exit(2)
    message, _, _ = run_cmd(
        'colour_echo "{{4 + }} {{3 You have shared your theme successfully }}"'
    )
    print "\n    " + message.strip('\n')
    increment_app_state_variable_with_dialog('make-snake', 'shared', 1)
    exit(2)
    def register_handler(self, widget=None, arg=None):
        if not is_internet():
            internet_present = self.try_to_connect_to_internet()

            if not internet_present:
                quit_dialog = KanoDialog(
                    _("The package was returned to sender"),
                    _("I just tried to send your profile to Kano HQ, \n" \
                      "but it looks like I don't have any Internet! ") + \
                    "\n" + \
                    _("You can keep playing and I'll keep your \n" \
                      "profile safe in my brain until you connect.")
                )
                quit_dialog.run()

                Gtk.main_quit()
                return

        self.register_user_with_gui()
            def lengthy_process():
                button_dict = {"OK": {"return_value": self.CLOSE_FEEDBACK}}

                if not is_internet():
                    title = "No internet connection"
                    description = "Configure your connection"
                    button_dict = {"OK": {"return_value": self.LAUNCH_WIFI}}
                else:
                    success, error = self.send_user_info(body_title=body_title)
                    if success:
                        title = "Info"
                        description = "Feedback sent correctly"
                        button_dict = {"OK": {"return_value": self.CLOSE_FEEDBACK}}
                    else:
                        title = "Info"
                        description = "Something went wrong, error: {}".format(error)
                        button_dict = {
                            "CLOSE FEEDBACK": {"return_value": self.CLOSE_FEEDBACK, "color": "red"},
                            "TRY AGAIN": {"return_value": self.KEEP_OPEN, "color": "green"},
                        }

                def done(title, description, button_dict):
                    self.set_cursor_to_normal()
                    self._send_button.stop_spinner()
                    self._send_button.set_sensitive(True)
                    self._text.set_sensitive(True)

                    # If the user decides to launch the wifi config,
                    # the window needs to be able to go below kano-settings
                    self.set_keep_above(False)

                    kdialog = KanoDialog(title, description, button_dict, parent_window=self)
                    kdialog.dialog.set_keep_above(False)
                    response = kdialog.run()

                    if response == self.LAUNCH_WIFI:
                        run_cmd("sudo /usr/bin/kano-settings 12")
                        self.after_feedback_sent(completed=False)
                    elif response == self.CLOSE_FEEDBACK:
                        self.after_feedback_sent(completed=True)

                GObject.idle_add(done, title, description, button_dict)
Exemple #32
0
        def __init__(self,
                     screen_number=None,
                     screen_name=None,
                     socket_id=0,
                     onescreen=False):
            # Check for internet, if screen is 12 means no internet
            if screen_number == 12 or screen_name == 'no-internet':
                common.has_internet = False
            else:
                common.has_internet = is_internet()

            # Set combobox styling to the screen
            # Is done here so we don't attach the styling multiple times when
            # switching screens
            apply_styling_to_screen(self.CSS_PATH)
            apply_common_to_screen()
            KanoComboBox.apply_styling_to_screen()
            ScrolledWindow.apply_styling_to_screen(wide=True)

            # Set window
            base_class.__init__(self, _("Settings"), self.width, self.height,
                                socket_id)

            self.set_decorated(True)
            self.top_bar = TopBar(_("Settings"))
            self.top_bar.set_close_callback(self.close_window)
            self.prev_handler = None
            self.set_icon_name('kano-settings')

            if self._base_name == "Window":
                self.set_titlebar(self.top_bar)

            self._onescreen = onescreen

            self.connect('delete-event', Gtk.main_quit)
            # In case we are called from kano-world-launcher, terminate splash
            os.system('kano-stop-splash')
            # Init to Home Screen
            HomeScreen(self,
                       screen_number=screen_number,
                       screen_name=screen_name)
Exemple #33
0
def share_theme():
    # Check for internet
    if not is_internet():
        coloured_error, _, _ = run_cmd('colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip('\n') + 'You need internet connection'
        exit(2)
    # Check for login
    success, _ = login_using_token()
    if not success:
        coloured_error, _, _ = run_cmd('colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip('\n') + 'You need to login to Kano World'
        exit(2)
    # Print themes
    print_themes(False, False)
    # Select theme dialogue
    message = "    1) Select a theme: "
    theme = raw_input(message)
    theme += '.xml'
    # Check theme exists
    check_valid_theme(theme)
    # Select title
    message = "    2) Write a title: "
    title = raw_input(message)
    if not title:
        title = 'My snake'
    # Select description
    message = "    3) Write a description: "
    description = raw_input(message)
    # Create json
    create_share_json(theme, title, description)
    # Share
    filepath = os.path.join(app_dir, theme)
    success, msg = upload_share(filepath, title, 'make-snake')
    if not success:
        coloured_error, _, _ = run_cmd('colour_echo "{{8 x }} {{7 error: }}"')
        print "\n    " + coloured_error.strip('\n') + 'Sharing of %s failed. %s\n' % (theme, msg)
        exit(2)
    message, _, _ = run_cmd('colour_echo "{{4 + }} {{3 You have shared your theme successfully }}"')
    print "\n    " + message.strip('\n')
    increment_app_state_variable_with_dialog('make-snake', 'shared', 1)
    exit(2)
Exemple #34
0
    def _load_remote_prompts(self, num_retries=10):
        '''
        Get the prompts/questions through a request,
        retrying <num_retries> if network is not up.
        '''
        for attempt in xrange(0, num_retries):
            if attempt != 0:
                time.sleep(2)

            if not is_internet():
                continue

            try:
                # Contact Kano questions API
                success, error, res = request_wrapper('get', '/questions')

                if not success:
                    logger.warn(
                        'Error loading prompts from API (try {}): {}'.format(
                            attempt, error))
                    continue

                prompts = sorted(res['questions'],
                                 key=lambda k: k['date_created'])

                if not len(prompts):
                    return False

                self.prompts = prompts

                return True

            except Exception as exception:
                logger.error('Error loading prompts (try {}): {}'.format(
                    attempt, exception))

        return False
    def try_to_connect_to_internet(self, attempt_no=1):
        """
        Attempt to connect to the internet
        :param attempt_no: Number of connection attempts already tried
        :returns: If the attempt resulted in an Internet connection
        """

        if attempt_no == 1:
            title = _("You don't have internet!")
            description = _("Connect to WiFi and try again.")
        else:
            title = _("Still not connected...")
            description = _("Seems like you're having trouble connecting.") + \
                "\n" + _("Try again later at another point")

        connect_choice = self.connect_dialog(title, description)

        if connect_choice == 'connect':
            self.win.blur()

            while Gtk.events_pending():
                Gtk.main_iteration()

            logger.debug("Launching WiFi GUI, attempt #{}".format(attempt_no))
            os.system("sudo /usr/bin/kano-wifi-gui")
            logger.debug("Finished connection attempt #{}".format(attempt_no))

            if is_internet():
                return True

            if attempt_no >= 2:
                return False

            return self.try_to_connect_to_internet(attempt_no + 1)
        else:
            return False
        def __init__(self, screen_number=None, screen_name=None,
                     socket_id=0, onescreen=False):
            # Check for internet, if screen is 12 means no internet
            if screen_number == 12 or screen_name == 'no-internet':
                common.has_internet = False
            else:
                common.has_internet = is_internet()

            # Set combobox styling to the screen
            # Is done here so we don't attach the styling multiple times when
            # switching screens
            apply_styling_to_screen(self.CSS_PATH)
            apply_common_to_screen()
            KanoComboBox.apply_styling_to_screen()
            ScrolledWindow.apply_styling_to_screen(wide=True)

            # Set window
            base_class.__init__(self, _("Settings"), self.width,
                                self.height, socket_id)

            self.set_decorated(True)
            self.top_bar = TopBar(_("Settings"))
            self.top_bar.set_close_callback(self.close_window)
            self.prev_handler = None
            self.set_icon_name('kano-settings')

            if self._base_name == "Window":
                self.set_titlebar(self.top_bar)

            self._onescreen = onescreen

            self.connect('delete-event', Gtk.main_quit)
            # In case we are called from kano-world-launcher, terminate splash
            os.system('kano-stop-splash')
            # Init to Home Screen
            HomeScreen(self, screen_number=screen_number, screen_name=screen_name)
    def _load_remote_prompts(self, num_retries=10):
        '''
        Get the prompts/questions through a request,
        retrying <num_retries> if network is not up.
        '''
        for attempt in xrange(0, num_retries):
            if attempt != 0:
                time.sleep(2)

            if not is_internet():
                continue

            try:
                # Contact Kano questions API
                success, error, res = request_wrapper('get', '/questions')

                if not success:
                    logger.warn('Error loading prompts from API (try {}): {}'
                                .format(attempt, error))
                    continue

                prompts = sorted(res['questions'],
                                 key=lambda k: k['date_created'])

                if not len(prompts):
                    return False

                self.prompts = prompts

                return True

            except Exception as exception:
                logger.error('Error loading prompts (try {}): {}'
                             .format(attempt, exception))

        return False
Exemple #38
0
 def is_fulfilled(self):
     return is_internet()
Exemple #39
0
def check_for_updates(min_time_between_checks=0, progress=None):
    status = UpdaterStatus.get_instance()

    # FIXME: FOR DEBUGGING ONLY
    #status.state = UpdaterStatus.UPDATES_AVAILABLE
    #status.last_check = int(time.time())
    #status.save()
    #return True

    if not progress:
        progress = DummyProgress()

    if status.state != UpdaterStatus.NO_UPDATES:
        msg = _('No need to check for updates')
        logger.info(msg)
        progress.abort(msg)

        # Return True in all cases except when the state is UPDATES_INSTALLED
        # In that case, we've just updated and don't want to check for updates
        # again.
        return status.state != UpdaterStatus.UPDATES_INSTALLED

    if min_time_between_checks:
        target_delta = float(min_time_between_checks) * 60 * 60

        time_now = time.time()
        delta = time_now - status.last_check

        if delta > target_delta:
            logger.info(_('Time check passed, doing update check!'))
        else:
            msg = _('Not enough time passed for a new update check!')
            logger.info(msg)
            progress.abort(msg)
            return False

    if not is_internet():
        err_msg = _('Must have internet to check for updates')
        logger.error(err_msg)
        progress.fail(err_msg)
        return False

    if not is_server_available():
        err_msg = _('Could not connect to the download server')
        logger.error(err_msg)
        progress.fail(err_msg)
        return False

    if _do_check(progress):
        status.state = UpdaterStatus.UPDATES_AVAILABLE
        logger.debug('Updates available')
        rv = True
    else:
        status.state = UpdaterStatus.NO_UPDATES
        logger.debug('No updates available')
        rv = False

    status.last_check = int(time.time())
    status.save()

    return rv
Exemple #40
0
def check_for_updates(progress=None, priority=Priority.NONE, is_gui=False):
    status = UpdaterStatus.get_instance()

    # FIXME: FOR DEBUGGING ONLY
    #status.state = UpdaterStatus.UPDATES_AVAILABLE
    #status.last_check = int(time.time())
    #status.save()
    #return True

    if not progress:
        progress = DummyProgress()

    countdown = status.first_boot_countdown - int(time.time())

    # block update checks when:
    #  1) three days have NOT passed since the first boot
    #  2) and not checking for URGENT updates
    #  3) and the check is triggered from background hooks (not by user)
    if (countdown > 0) and (priority is not Priority.URGENT) and (not is_gui):
        return False

    if status.state != UpdaterStatus.NO_UPDATES:
        msg = _('No need to check for updates')
        logger.info(msg)

        # This was a successful check, so we need to update the timestamp.
        status.last_check = int(time.time())
        status.save()

        # Return True in all cases except when the state is UPDATES_INSTALLED
        # In that case, we've just updated and don't want to check for updates
        # again.
        return status.state != UpdaterStatus.UPDATES_INSTALLED

    if not is_internet():
        err_msg = _('Must have internet to check for updates')
        logger.error(err_msg)
        progress.fail(err_msg)

        # Not updating the timestamp. The check failed.
        return False

    if not is_server_available():
        err_msg = _('Could not connect to the download server')
        logger.error(err_msg)
        progress.fail(err_msg)

        # Not updating the timestamp. The check failed.
        return False


    update_type = _do_check(progress, priority=priority)
    if update_type == Priority.NONE:
        status.state = UpdaterStatus.NO_UPDATES
        logger.debug('No updates available')
        rv = False
    else:
        if update_type == Priority.URGENT:
            status.notifications_muted = True
            status.is_urgent = True

        status.state = UpdaterStatus.UPDATES_AVAILABLE
        logger.debug('Updates available')
        logger.debug('Found update of priority: {}'.format(priority.priority))
        rv = True

    if priority <= Priority.STANDARD:
        status.last_check = int(time.time())

    status.last_check_urgent = int(time.time())

    status.save()

    return rv
Exemple #41
0
def check_for_updates(progress=None, priority=Priority.NONE, is_gui=False):
    status = UpdaterStatus.get_instance()

    if not progress:
        progress = DummyProgress()

    countdown = status.first_boot_countdown - int(time.time())

    # block update checks when:
    #  1) three days have NOT passed since the first boot
    #  2) and not checking for URGENT updates
    #  3) and the check is triggered from background hooks (not by user)
    if (countdown > 0) and (priority is not Priority.URGENT) and (not is_gui):
        return False

    if status.state not in [UpdaterStatus.NO_UPDATES, UpdaterStatus.UPDATES_DOWNLOADED]:
        msg = "No need to check for updates"
        logger.info(msg)

        # This was a successful check, so we need to update the timestamp.
        status.last_check = int(time.time())
        status.save()

        # Return True in all cases except when the state is UPDATES_INSTALLED
        # In that case, we've just updated and don't want to check for updates
        # again.
        return status.state != UpdaterStatus.UPDATES_INSTALLED

    if not is_internet():
        err_msg = N_("Must have internet to check for updates")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        RCState.get_instance().rc = RC.NO_NETWORK

        # Not updating the timestamp. The check failed.
        return False

    if not is_server_available():
        err_msg = N_("Could not connect to the download server")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        RCState.get_instance().rc = RC.CANNOT_REACH_KANO

        # Not updating the timestamp. The check failed.
        return False

    update_type = _do_check(progress, priority=priority)
    if update_type == Priority.NONE:
        # If the Updater is running in recovery mode, do not update the state
        # out of the installing ones, otherwise the recovery flow will quit.
        if not status.is_recovery_needed():
            status.state = UpdaterStatus.NO_UPDATES
        logger.info("No updates available")
        RCState.get_instance().rc = RC.NO_UPDATES_AVAILABLE
        rv = False
    else:
        if update_type == Priority.URGENT:
            status.notifications_muted = True
            status.is_urgent = True

        if not status.is_recovery_needed():
            status.state = UpdaterStatus.UPDATES_AVAILABLE
        logger.info("Updates available")
        logger.info("Found update of priority: {}".format(priority.priority))
        rv = True

    if priority <= Priority.STANDARD:
        status.last_check = int(time.time())

    # always check independent packages as NONE as urgent updates to
    # these packages are dealt with by the main updater
    status.updatable_independent_packages = get_ind_packages(Priority.NONE)

    status.last_check_urgent = int(time.time())

    status.save()

    return rv
Exemple #42
0
def check_for_updates(progress=None, priority=Priority.NONE, is_gui=False):
    status = UpdaterStatus.get_instance()

    # FIXME: FOR DEBUGGING ONLY
    #status.state = UpdaterStatus.UPDATES_AVAILABLE
    #status.last_check = int(time.time())
    #status.save()
    #return True

    if not progress:
        progress = DummyProgress()

    countdown = status.first_boot_countdown - int(time.time())

    # block update checks when:
    #  1) three days have NOT passed since the first boot
    #  2) and not checking for URGENT updates
    #  3) and the check is triggered from background hooks (not by user)
    if (countdown > 0) and (priority is not Priority.URGENT) and (not is_gui):
        return False

    if status.state != UpdaterStatus.NO_UPDATES:
        msg = "No need to check for updates"
        logger.info(msg)

        # This was a successful check, so we need to update the timestamp.
        status.last_check = int(time.time())
        status.save()

        # Return True in all cases except when the state is UPDATES_INSTALLED
        # In that case, we've just updated and don't want to check for updates
        # again.
        return status.state != UpdaterStatus.UPDATES_INSTALLED

    if not is_internet():
        err_msg = N_("Must have internet to check for updates")
        logger.error(err_msg)
        progress.fail(_(err_msg))

        # Not updating the timestamp. The check failed.
        return False

    if not is_server_available():
        err_msg = N_("Could not connect to the download server")
        logger.error(err_msg)
        progress.fail(_(err_msg))

        # Not updating the timestamp. The check failed.
        return False

    update_type = _do_check(progress, priority=priority)
    if update_type == Priority.NONE:
        status.state = UpdaterStatus.NO_UPDATES
        logger.debug("No updates available")
        rv = False
    else:
        if update_type == Priority.URGENT:
            status.notifications_muted = True
            status.is_urgent = True

        status.state = UpdaterStatus.UPDATES_AVAILABLE
        logger.debug("Updates available")
        logger.debug("Found update of priority: {}".format(priority.priority))
        rv = True

    if priority <= Priority.STANDARD:
        status.last_check = int(time.time())

    # always check independent packages as NONE as urgent updates to
    # these packages are dealt with by the main updater
    status.updatable_independent_packages = get_ind_packages(Priority.NONE)

    status.last_check_urgent = int(time.time())

    status.save()

    return rv
    def _on_register_button(self, widget=None):  # TODO: refactor this
        """
        """
        if not is_internet():
            self._show_not_internet_dialog()
            return

        # Get the username, password and birthday
        data = self.data_screen.get_widget_data()
        email = data['email']
        username = data['username']

        # Validate that the email address format is correct
        email_error = validate_email(email)
        if email_error:
            self._show_error_dialog(_("Incorrect Email address"), email_error)
            return

        if not self._is_username_available(username):
            self._show_username_taken_dialog(username)
            return

        # We can save the username to kano-profile
        # Don't save password as this is private
        self.data_screen.save_username_and_birthday()  # TODO: rename this
        self.data_screen.cache_emails()
        data = self.data_screen.get_widget_data()

        # This means no threads are needed.
        while Gtk.events_pending():  # TODO: why is this needed?
            Gtk.main_iteration()

        # Try and register the account on the server
        password = data['password']
        success, text = register_(email, username, password,
                                  marketing_enabled=True)

        # This should no longer be needed, since this is checked in the first
        # screen. However there is a small chance someone could take the
        # username while the user is in the process of registering
        if not success:
            if text.strip() == _("Cannot register, problem: "
               "Username already registered"):

                self._show_username_taken_dialog(username)

            else:
                logger.info("problem with registration: {}".format(text))
                return_value = 'FAIL'
                self._create_dialog(
                    title=_("Houston, we have a problem"),
                    description=str(text)
                )
                track_data('world-registration-failed', {'reason': text})

        else:
            logger.info("registration successful")

            # saving hardware info and initial Kano version
            save_hardware_info()
            save_kano_version()

            # running kano-sync after registration
            logger.info("running kano-sync after successful registration")
            cmd = '{bin_dir}/kano-sync --sync -s'.format(bin_dir=bin_dir)
            run_bg(cmd)

            return_value = 'SUCCEED'
            self._create_dialog(
                title=_("Profile activated!"),
                description=_("Now you can share stuff, build your character, "
                              "and connect with friends.")
            )

        self.win.get_window().set_cursor(None)

        # Close the app if it was successful
        if return_value == 'SUCCEED':
            Gtk.main_quit()
Exemple #44
0
 def _cb_wrapper(self, widget, connected_cb, fail_cb):
     # if there is internet, then the user suceeded with connecting
     if is_internet():
         connected_cb()
     else:
         fail_cb()
    def next_page(self, widget):
        age, bday_date, error = self.data_screen.calculate_age()

        if age == -1:
            self._show_error_dialog(error[0], error[1])
            return

        # Get the username, password and birthday
        data = self.data_screen.get_widget_data()
        username = data["username"]

        if not is_internet():
            kd = KanoDialog(
                "You don't have internet",
                "Do you want to connect to WiFi?",
                [
                    {
                        "label": "YES",
                        "color": "green",
                        "return_value": 0
                    },
                    {
                        "label": "NO",
                        "color": "red",
                        "return_value": 1
                    }
                ],
                parent_window=self.win
            )
            response = kd.run()

            # Close the dialog
            while Gtk.events_pending():
                Gtk.main_iteration()

            if response == 0:
                subprocess.Popen("sudo kano-wifi-gui", shell=True)

            return

        if not self.is_username_available(username):
            track_data('world-registration-username-taken',
                       {'username': username})
            kd = KanoDialog(
                "This username is taken!",
                "Try another one",
                parent_window=self.win
            )
            kd.run()
            self.data_screen.username.set_text("")
            self.data_screen.validate_username()
            self.data_screen.username.grab_focus()
            return

        self.win.data = data

        # We can save the username and birthday to kano-profile
        # Don't save password as this is private
        self.data_screen.save_username_and_birthday()

        self.win.remove_main_widget()

        # Pass the age to the third registration screen so we can show the
        # appropriate number of entries available
        RegistrationScreen2(self.win, age)
Exemple #46
0
 def is_fulfilled(self):
     return is_internet()
Exemple #47
0
    def __init__(self, win):

        Template.__init__(self, "", _("to be set"), _("COMPLETE"))

        self.win = win
        self.win.set_main_widget(self)

        self.kano_button.connect('button-release-event', self.win.go_to_home)

        internet_img = Gtk.Image()

        # Very hacky way to centre the Proxy button - put spaces in the label
        self.proxy_button = OrangeButton(_("Proxy  "))
        self.proxy_button.connect('button-release-event', self.go_to_proxy)
        self.disable_proxy = OrangeButton(_("Disable proxy"))

        self.win.change_prev_callback(self.win.go_to_home)
        self.win.top_bar.enable_prev()

        internet_status = Gtk.Label()
        internet_status_style = internet_status.get_style_context()
        internet_status.set_alignment(xalign=1, yalign=0.5)

        internet_action = Gtk.Label()
        internet_action_style = internet_action.get_style_context()
        internet_status_style.add_class('internet_status_top')
        internet_action_style.add_class('internet_status_bottom')
        internet_action.set_alignment(xalign=1, yalign=0.5)

        status_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
        status_box.props.valign = Gtk.Align.CENTER

        configure_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)

        container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
        container.pack_start(status_box, False, False, 2)
        container.pack_start(internet_img, False, False, 2)
        self.box.pack_start(container, False, False, 0)

        network_info_dict = network_info()
        common.has_internet = is_internet()

        if not common.has_internet or not network_info_dict:
            if network_info_dict:
                description = _("Use the browser to log in or configure proxy")
            else:
                description = _("Configure wireless")

            title = _("Get connected")

            self.add_connection = KanoButton(_("WIFI"))
            self.add_connection.connect('button_release_event', self.configure_wifi)
            # We removed the ability to use keyboard to click, so we also remove ability
            # to get keyboard focus
            self.add_connection.set_can_focus(False)

            # For now, this is removed as the event listener is interefering with the
            # kano-connect
            #self.add_connection.connect("key_release_event", self.configure_wifi)

            status_box.pack_start(self.add_connection, False, False, 0)
            internet_img.set_from_file(common.media + "/Graphics/Internet-noConnection.png")
            internet_status.set_text(_("No network found"))
            self.kano_button.set_label(_("BACK"))

            status_box.pack_start(configure_container, False, False, 3)

            go_to_portal_button = OrangeButton(_("Browser Login"))
            go_to_portal_button.connect('button-press-event', self.cb_launch_browser)
            configure_container.pack_start(go_to_portal_button, False, False, 0)

            divider_label = Gtk.Label("|")
            configure_container.pack_start(divider_label, False, False, 3)

            configure_container.pack_end(self.proxy_button, False, False, 0)

        else:
            self.kano_button.set_label(_("COMPLETE"))

            status_box.pack_start(internet_status, False, False, 3)
            status_box.pack_start(internet_action, False, False, 3)
            status_box.pack_start(configure_container, False, False, 3)

            network = network_info_dict.keys()[0]
            ip = network_info_dict[network]['address']
            network_text = network_info_dict[network]['nice_name']

            internet_img.set_from_file(common.media + "/Graphics/Internet-Connection.png")

            internet_status.set_text(network_text)
            internet_action.set_text(ip)

            go_to_portal_button = OrangeButton(_("Browser Login"))
            go_to_portal_button.connect('button-press-event', self.cb_launch_browser)
            configure_container.pack_start(go_to_portal_button, False, False, 0)

            if network_text == 'Ethernet':
                title = _("Connection found!")
                description = _("You're on a wired network")
                # Change to ethernet image here
                internet_img.set_from_file(common.media + "/Graphics/Internet-ethernetConnection.png")

            else:
                title = _("Connection found!")
                description = _("You're on a wireless network")

                divider_label = Gtk.Label("|")
                configure_container.pack_start(divider_label, False, False, 3)

                configure_button = OrangeButton(_("Configure"))
                configure_button.connect('button_press_event', self.configure_wifi)
                configure_container.pack_start(configure_button, False, False, 0)

            divider_label = Gtk.Label("|")
            configure_container.pack_start(divider_label, False, False, 3)
            configure_container.pack_end(self.proxy_button, False, False, 0)

        self.title.title.set_text(title)
        self.title.description.set_text(description)
        self.win.show_all()
Exemple #48
0
def download(progress=None, gui=True):
    status = UpdaterStatus.get_instance()
    dialog_proc = None

    if not progress:
        progress = DummyProgress()

    if status.state == UpdaterStatus.NO_UPDATES:
        progress.split(
            Phase(
                'checking',
                _("Checking for updates"),
                10,
                is_main=True
            ),
            Phase(
                'downloading',
                _("Downloading updates"),
                90,
                is_main=True
            )
        )
        progress.start('checking')
        check_for_updates(progress=progress)
        if status.state == UpdaterStatus.NO_UPDATES:
            logger.info("No updates to download")
            progress.finish(_("No updates to download"))
            return False

        progress.start('downloading')

    elif status.state == UpdaterStatus.UPDATES_DOWNLOADED:
        err_msg = N_("Updates have been downloaded already")
        logger.error(err_msg)
        progress.abort(_(err_msg))
        return True

    elif status.state == UpdaterStatus.DOWNLOADING_UPDATES:
        err_msg = N_("The download is already running")
        logger.error(err_msg)
        progress.abort(_(err_msg))
        return False

    elif status.state == UpdaterStatus.INSTALLING_UPDATES:
        err_msg = N_("Updates are already being installed")
        logger.error(err_msg)
        progress.abort(_(err_msg))
        return False

    if not is_internet():
        err_msg = N_("Must have internet to download the updates")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        return False

    if not is_server_available():
        err_msg = N_("Could not connect to the download server")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        return False

    # show a dialog informing the user of an automatic urgent download
    if status.is_urgent and not gui:
        # TODO: mute notifications?
        title = _("Updater")
        description = _("Kano HQ has just released a critical update that will repair" \
                        " some important things on your system! We'll download these automatically," \
                        " and ask you to schedule the install when they finish.")
        buttons = _("OK:green:1")
        dialog_proc = show_kano_dialog(title, description, buttons, blocking=False)

    status.state = UpdaterStatus.DOWNLOADING_UPDATES
    status.save()

    priority = Priority.NONE

    if status.is_urgent:
        priority = Priority.URGENT
        logger.info("Urgent update detected, bumping to normal priority")
        make_normal_prio()

    logger.debug("Downloading with priority {}".format(priority.priority))

    try:
        success = do_download(progress, status, priority=priority, dialog_proc=dialog_proc)
    except Exception as err:
        progress.fail(err.message)
        logger.error(err.message)

        status.state = UpdaterStatus.UPDATES_AVAILABLE
        status.save()

        return False

    status.state = UpdaterStatus.UPDATES_DOWNLOADED
    status.save()

    return success
Exemple #49
0
def download(progress=None, gui=True):
    status = UpdaterStatus.get_instance()
    dialog_proc = None

    if not progress:
        progress = DummyProgress()

    if status.state == UpdaterStatus.NO_UPDATES:
        progress.split(
            Phase(
                'checking',
                _('Checking for updates'),
                10,
                is_main=True
            ),
            Phase(
                'downloading',
                _('Downloading updates'),
                90,
                is_main=True
            )
        )
        progress.start('checking')
        check_for_updates(progress=progress)
        if status.state == UpdaterStatus.NO_UPDATES:
            progress.finish(_('No updates to download'))
            return False

        progress.start('downloading')

    elif status.state == UpdaterStatus.UPDATES_DOWNLOADED:
        err_msg = _('Updates have been downloaded already')
        logger.error(err_msg)
        progress.abort(err_msg)
        return True

    elif status.state == UpdaterStatus.DOWNLOADING_UPDATES:
        err_msg = _('The download is already running')
        logger.error(err_msg)
        progress.abort(err_msg)
        return False

    elif status.state == UpdaterStatus.INSTALLING_UPDATES:
        err_msg = _('Updates are already being installed')
        logger.error(err_msg)
        progress.abort(err_msg)
        return False

    if not is_internet():
        err_msg = _('Must have internet to download the updates')
        logger.error(err_msg)
        progress.fail(err_msg)
        return False

    if not is_server_available():
        err_msg = _('Could not connect to the download server')
        logger.error(err_msg)
        progress.fail(err_msg)
        return False

    # show a dialog informing the user of an automatic urgent download
    if status.is_urgent and not gui:
        # TODO: mute notifications?
        title = "Updater"
        description = "Kano HQ has just released a critical update that will repair" \
                      " some important things on your system! We'll download these automatically," \
                      " and ask you to schedule the install when they finish."
        buttons = "OK:green:1"
        dialog_proc = show_kano_dialog(title, description, buttons, blocking=False)

    status.state = UpdaterStatus.DOWNLOADING_UPDATES
    status.save()

    priority = Priority.NONE

    if status.is_urgent:
        priority = Priority.URGENT
        logger.info('Urgent update detected, bumping to normal priority')
        make_normal_prio()

    logger.debug('Downloading with priority {}'.format(priority.priority))

    try:
        success = do_download(progress, status, priority=priority, dialog_proc=dialog_proc)
    except Exception as err:
        progress.fail(err.message)
        logger.error(err.message)

        status.state = UpdaterStatus.UPDATES_AVAILABLE
        status.save()

        return False

    status.state = UpdaterStatus.UPDATES_DOWNLOADED
    status.save()

    return success
Exemple #50
0
            def lengthy_process():
                button_dict = {_("OK"): {"return_value": self.CLOSE_FEEDBACK}}

                if not is_internet():
                    title = _("No internet connection")
                    description = _("Configure your connection")
                    button_dict = {_("OK"): {"return_value": self.LAUNCH_WIFI}}
                else:
                    success, error = self.send_user_info(body_title=body_title)
                    if success:
                        title = _("Info")
                        description = _("Feedback sent correctly")
                        button_dict = \
                            {
                                _("OK"):
                                {
                                    "return_value": self.CLOSE_FEEDBACK
                                }
                            }
                    else:
                        title = _("Info")
                        description = _(
                            "Something went wrong, error: {}").format(error)
                        button_dict = \
                            {
                                _("CLOSE FEEDBACK"):
                                {
                                    "return_value": self.CLOSE_FEEDBACK,
                                    "color": "red"
                                },
                                _("TRY AGAIN"):
                                {
                                    "return_value": self.KEEP_OPEN,
                                    "color": "green"
                                }
                            }

                def done(title, description, button_dict):
                    self.set_cursor_to_normal()
                    self._send_button.stop_spinner()
                    self._send_button.set_sensitive(True)
                    self._text.set_sensitive(True)

                    # If the user decides to launch the wifi config,
                    # the window needs to be able to go below kano-settings
                    self.set_keep_above(False)

                    kdialog = KanoDialog(title,
                                         description,
                                         button_dict,
                                         parent_window=self)
                    kdialog.dialog.set_keep_above(False)
                    response = kdialog.run()

                    if response == self.LAUNCH_WIFI:
                        run_cmd('sudo /usr/bin/kano-settings 12',
                                localised=True)
                        self.after_feedback_sent(completed=False)
                    elif response == self.CLOSE_FEEDBACK:
                        self.after_feedback_sent(completed=True)

                GObject.idle_add(done, title, description, button_dict)
Exemple #51
0
def download(progress=None, gui=True):
    status = UpdaterStatus.get_instance()
    dialog_proc = None

    if not progress:
        progress = DummyProgress()

    if status.state in [
            UpdaterStatus.NO_UPDATES, UpdaterStatus.UPDATES_DOWNLOADED
    ]:
        progress.split(
            Phase('checking', _("Checking for updates"), 10, is_main=True),
            Phase('downloading', _("Downloading updates"), 90, is_main=True))
        pre_check_state = status.state
        progress.start('checking')
        check_for_updates(progress=progress)

        if status.state == UpdaterStatus.NO_UPDATES:
            if pre_check_state == UpdaterStatus.NO_UPDATES:
                msg = N_("No updates to download")
                logger.info(msg)
                progress.finish(_(msg))
                return False
            elif pre_check_state == UpdaterStatus.UPDATES_DOWNLOADED:
                err_msg = N_("Latest updates have been downloaded already")
                logger.info(err_msg)
                progress.abort(_(err_msg))
                return True

        progress.start('downloading')

    elif status.state == UpdaterStatus.DOWNLOADING_UPDATES:
        err_msg = N_("The download is already running")
        logger.error(err_msg)
        progress.abort(_(err_msg))
        return False

    if not is_internet():
        err_msg = N_("Must have internet to download the updates")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        RCState.get_instance().rc = RC.NO_NETWORK
        return False

    if not is_server_available():
        err_msg = N_("Could not connect to the download server")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        RCState.get_instance().rc = RC.CANNOT_REACH_KANO
        return False

    # show a dialog informing the user of an automatic urgent download
    if status.is_urgent and not gui:
        # TODO: mute notifications?
        title = _("Updater")
        description = _(
            "Kano HQ has just released a critical update that will repair"
            " some important things on your system! We'll download these"
            " automatically, and ask you to schedule the install when they finish."
        )
        buttons = _("OK:green:1")
        dialog_proc = show_kano_dialog(title,
                                       description,
                                       buttons,
                                       blocking=False)

    # If the Updater is running in recovery mode, do not update the state
    # out of the installing ones, otherwise the recovery flow will quit.
    if not status.is_recovery_needed():
        status.state = UpdaterStatus.DOWNLOADING_UPDATES
        status.save()

    priority = Priority.NONE

    if status.is_urgent:
        priority = Priority.URGENT
        logger.info("Urgent update detected, bumping to normal priority")
        make_normal_prio()

    logger.debug("Downloading with priority {}".format(priority.priority))

    try:
        success = do_download(progress,
                              status,
                              priority=priority,
                              dialog_proc=dialog_proc)
    except Exception as err:
        progress.fail(err.message)
        logger.error(err.message)
        RCState.get_instance().rc = RC.UNEXPECTED_ERROR

        status.state = UpdaterStatus.UPDATES_AVAILABLE
        status.save()

        return False

    if not status.is_recovery_needed():
        status.state = UpdaterStatus.UPDATES_DOWNLOADED
        status.save()

    return success
    def _on_register_button(self, widget=None):  # TODO: refactor this
        """
        """
        if not is_internet():
            self._show_not_internet_dialog()
            return

        # Get the username, password and birthday
        data = self.data_screen.get_widget_data()
        email = data['email']
        username = data['username']

        # Validate that the email address format is correct
        email_error = validate_email(email)
        if email_error:
            self._show_error_dialog(_("Incorrect Email address"), email_error)
            return

        if not self._is_username_available(username):
            self._show_username_taken_dialog(username)
            return

        # We can save the username to kano-profile
        # Don't save password as this is private
        self.data_screen.save_username_and_birthday()  # TODO: rename this
        self.data_screen.cache_emails()
        data = self.data_screen.get_widget_data()

        # This means no threads are needed.
        while Gtk.events_pending():  # TODO: why is this needed?
            Gtk.main_iteration()

        # Try and register the account on the server
        password = data['password']
        success, text = register_(email,
                                  username,
                                  password,
                                  marketing_enabled=True)

        # This should no longer be needed, since this is checked in the first
        # screen. However there is a small chance someone could take the
        # username while the user is in the process of registering
        if not success:
            if text.strip() == _("Cannot register, problem: "
                                 "Username already registered"):

                self._show_username_taken_dialog(username)

            else:
                logger.info("problem with registration: {}".format(text))
                return_value = 'FAIL'
                self._create_dialog(title=_("Houston, we have a problem"),
                                    description=str(text))
                track_data('world-registration-failed', {'reason': text})

        else:
            logger.info("registration successful")

            # saving hardware info and initial Kano version
            save_hardware_info()
            save_kano_version()

            # running kano-sync after registration
            logger.info("running kano-sync after successful registration")
            cmd = '{bin_dir}/kano-sync --sync -s'.format(bin_dir=bin_dir)
            run_bg(cmd)

            return_value = 'SUCCEED'
            self._create_dialog(
                title=_("Profile activated!"),
                description=_("Now you can share stuff, build your character, "
                              "and connect with friends."))

        self.win.get_window().set_cursor(None)

        # Close the app if it was successful
        if return_value == 'SUCCEED':
            Gtk.main_quit()
Exemple #53
0
    def __init__(self, win):

        Template.__init__(self, "", _("to be set"), _("COMPLETE"))

        self.win = win
        self.win.set_main_widget(self)

        self.kano_button.connect('button-release-event', self.win.go_to_home)

        internet_img = Gtk.Image()

        # Very hacky way to centre the Proxy button - put spaces in the label
        self.proxy_button = OrangeButton(_("Proxy  "))
        self.proxy_button.connect('button-release-event', self.go_to_proxy)
        self.disable_proxy = OrangeButton(_("Disable proxy"))

        self.win.change_prev_callback(self.win.go_to_home)
        self.win.top_bar.enable_prev()

        internet_status = Gtk.Label()
        internet_status_style = internet_status.get_style_context()
        internet_status.set_alignment(xalign=1, yalign=0.5)

        internet_action = Gtk.Label()
        internet_action_style = internet_action.get_style_context()
        internet_status_style.add_class('internet_status_top')
        internet_action_style.add_class('internet_status_bottom')
        internet_action.set_alignment(xalign=1, yalign=0.5)

        status_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
        status_box.props.valign = Gtk.Align.CENTER

        configure_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
                                      spacing=0)

        container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
        container.pack_start(status_box, False, False, 2)
        container.pack_start(internet_img, False, False, 2)
        self.box.pack_start(container, False, False, 0)

        network_info_dict = network_info()
        common.has_internet = is_internet()

        if not common.has_internet or not network_info_dict:
            if network_info_dict:
                description = _("Use the browser to log in or configure proxy")
            else:
                description = _("Configure wireless")

            title = _("Get connected")

            self.add_connection = KanoButton(_("WIFI"))
            self.add_connection.connect('button_release_event',
                                        self.configure_wifi)
            # We removed the ability to use keyboard to click, so we also remove ability
            # to get keyboard focus
            self.add_connection.set_can_focus(False)

            # For now, this is removed as the event listener is interefering with the
            # kano-connect
            #self.add_connection.connect("key_release_event", self.configure_wifi)

            status_box.pack_start(self.add_connection, False, False, 0)
            internet_img.set_from_file(common.media +
                                       "/Graphics/Internet-noConnection.png")
            internet_status.set_text(_("No network found"))
            self.kano_button.set_label(_("BACK"))

            status_box.pack_start(configure_container, False, False, 3)

            go_to_portal_button = OrangeButton(_("Browser Login"))
            go_to_portal_button.connect('button-press-event',
                                        self.cb_launch_browser)
            configure_container.pack_start(go_to_portal_button, False, False,
                                           0)

            divider_label = Gtk.Label("|")
            configure_container.pack_start(divider_label, False, False, 3)

            configure_container.pack_end(self.proxy_button, False, False, 0)

        else:
            self.kano_button.set_label(_("COMPLETE"))

            status_box.pack_start(internet_status, False, False, 3)
            status_box.pack_start(internet_action, False, False, 3)
            status_box.pack_start(configure_container, False, False, 3)

            network = network_info_dict.keys()[0]
            ip = network_info_dict[network]['address']
            network_text = network_info_dict[network]['nice_name']

            internet_img.set_from_file(common.media +
                                       "/Graphics/Internet-Connection.png")

            internet_status.set_text(network_text)
            internet_action.set_text(ip)

            go_to_portal_button = OrangeButton(_("Browser Login"))
            go_to_portal_button.connect('button-press-event',
                                        self.cb_launch_browser)
            configure_container.pack_start(go_to_portal_button, False, False,
                                           0)

            if network_text == 'Ethernet':
                title = _("Connection found!")
                description = _("You're on a wired network")
                # Change to ethernet image here
                internet_img.set_from_file(
                    common.media + "/Graphics/Internet-ethernetConnection.png")

            else:
                title = _("Connection found!")
                description = _("You're on a wireless network")

                divider_label = Gtk.Label("|")
                configure_container.pack_start(divider_label, False, False, 3)

                configure_button = OrangeButton(_("Configure"))
                configure_button.connect('button_press_event',
                                         self.configure_wifi)
                configure_container.pack_start(configure_button, False, False,
                                               0)

            divider_label = Gtk.Label("|")
            configure_container.pack_start(divider_label, False, False, 3)
            configure_container.pack_end(self.proxy_button, False, False, 0)

        self.title.title.set_text(title)
        self.title.description.set_text(description)
        self.win.show_all()
Exemple #54
0
def download(progress=None):
    status = UpdaterStatus.get_instance()

    if not progress:
        progress = DummyProgress()

    if status.state == UpdaterStatus.NO_UPDATES:
        progress.split(
            Phase('checking', _('Checking for updates'), 10, is_main=True),
            Phase('downloading', _('Downloading updates'), 90, is_main=True))
        progress.start('checking')
        check_for_updates(progress=progress)
        if status.state == UpdaterStatus.NO_UPDATES:
            progress.finish(_('No updates to download'))
            return False

        progress.start('downloading')

    elif status.state == UpdaterStatus.UPDATES_DOWNLOADED:
        err_msg = _('Updates have been downloaded already')
        logger.error(err_msg)
        progress.abort(err_msg)
        return True

    elif status.state == UpdaterStatus.DOWNLOADING_UPDATES:
        err_msg = _('The download is already running')
        logger.error(err_msg)
        progress.abort(err_msg)
        return False

    elif status.state == UpdaterStatus.INSTALLING_UPDATES:
        err_msg = _('Updates are already being installed')
        logger.error(err_msg)
        progress.abort(err_msg)
        return False

    if not is_internet():
        err_msg = _('Must have internet to download the updates')
        logger.error(err_msg)
        progress.fail(err_msg)
        return False

    if not is_server_available():
        err_msg = _('Could not connect to the download server')
        logger.error(err_msg)
        progress.fail(err_msg)
        return False

    status.state = UpdaterStatus.DOWNLOADING_UPDATES
    status.save()

    try:
        success = do_download(progress, status)
    except Exception as err:
        progress.fail(err.message)
        logger.error(err.message)

        status.state = UpdaterStatus.UPDATES_AVAILABLE
        status.save()

        return False

    status.state = UpdaterStatus.UPDATES_DOWNLOADED
    status.save()

    return success
def download(progress=None, gui=True):
    status = UpdaterStatus.get_instance()
    dialog_proc = None

    if not progress:
        progress = DummyProgress()

    if status.state in [UpdaterStatus.NO_UPDATES, UpdaterStatus.UPDATES_DOWNLOADED]:
        progress.split(
            Phase(
                'checking',
                _("Checking for updates"),
                10,
                is_main=True
            ),
            Phase(
                'downloading',
                _("Downloading updates"),
                90,
                is_main=True
            )
        )
        pre_check_state = status.state
        progress.start('checking')
        check_for_updates(progress=progress)

        if status.state == UpdaterStatus.NO_UPDATES:
            if pre_check_state == UpdaterStatus.NO_UPDATES:
                msg = N_("No updates to download")
                logger.info(msg)
                progress.finish(_(msg))
                return False
            elif pre_check_state == UpdaterStatus.UPDATES_DOWNLOADED:
                err_msg = N_("Latest updates have been downloaded already")
                logger.info(err_msg)
                progress.abort(_(err_msg))
                return True

        progress.start('downloading')

    elif status.state == UpdaterStatus.DOWNLOADING_UPDATES:
        err_msg = N_("The download is already running")
        logger.error(err_msg)
        progress.abort(_(err_msg))
        return False

    if not is_internet():
        err_msg = N_("Must have internet to download the updates")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        RCState.get_instance().rc = RC.NO_NETWORK
        return False

    priority = Priority.NONE

    if status.is_urgent:
        priority = Priority.URGENT

    if not is_server_available():
        err_msg = N_("Could not connect to the download server")
        logger.error(err_msg)
        progress.fail(_(err_msg))
        RCState.get_instance().rc = RC.CANNOT_REACH_KANO
        return False

    run_cmd('sudo kano-empty-trash')
    enough_space, space_msg = check_disk_space(priority)
    if not enough_space:
        logger.error(space_msg)
        progress.abort(_(space_msg))
        RCState.get_instance().rc = RC.NOT_ENOUGH_SPACE
        return False

    # show a dialog informing the user of an automatic urgent download
    if status.is_urgent and not gui:
        # TODO: mute notifications?
        title = _("Updater")
        description = _(
            "Kano HQ has just released a critical update that will repair some"
            " important things on your system! We'll download these automatically,"
            " and ask you to schedule the install when they finish."
        )
        buttons = _("OK:green:1")
        dialog_proc = show_kano_dialog(title, description, buttons, blocking=False)

    # If the Updater is running in recovery mode, do not update the state
    # out of the installing ones, otherwise the recovery flow will quit.
    if not status.is_recovery_needed():
        status.state = UpdaterStatus.DOWNLOADING_UPDATES
        status.save()

    priority = Priority.NONE

    if status.is_urgent:
        priority = Priority.URGENT
        logger.info("Urgent update detected, bumping to normal priority")
        make_normal_prio()

    logger.debug("Downloading with priority {}".format(priority.priority))

    try:
        success = do_download(
            progress, status, priority=priority, dialog_proc=dialog_proc
        )
    except Exception as err:
        progress.fail(err.message)
        logger.error(err.message)
        RCState.get_instance().rc = RC.UNEXPECTED_ERROR

        status.state = UpdaterStatus.UPDATES_AVAILABLE
        status.save()

        return False

    if not status.is_recovery_needed():
        status.state = UpdaterStatus.UPDATES_DOWNLOADED
        status.save()

    return success