[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [gettor/master] Added create_links_file() and add_link() methods. See coments.



commit 7bdf92917320e95b4f2f9ae25a519995ef292dde
Author: ilv <ilv@xxxxxxxxxxxxxxxxxxxxxxxx>
Date:   Fri Jun 20 20:55:48 2014 -0400

    Added create_links_file() and add_link() methods. See coments.
---
 src/gettor.py |  121 +++++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 114 insertions(+), 7 deletions(-)

diff --git a/src/gettor.py b/src/gettor.py
index 40de034..3187fa1 100644
--- a/src/gettor.py
+++ b/src/gettor.py
@@ -2,6 +2,7 @@ import os
 import re
 import inspect
 import logging
+import tempfile
 import ConfigParser
 
 """
@@ -17,6 +18,11 @@ import ConfigParser
 
         Core.get_links(): Get the links. It throws ValueError and
                           RuntimeError on failure.
+                          
+        Core.create_links_file(): Create a file to store links of a given
+                                  provider.
+                                  
+        Core.add_link(): Add a link to a links file of a given provider.
 
     Exceptions:
         ValueError: Request for an unsupported locale/operating system.
@@ -70,7 +76,7 @@ class Core:
             Raises a RuntimeError if the configuration file doesn't exists
             or if something goes wrong while reading options from it.
 
-            Parameters:
+            Arguments:
                 config_file: path for the configuration file
         """
 
@@ -142,19 +148,19 @@ class Core:
         info_log = logging.FileHandler(os.path.join(self.logdir, 'info.log'),
                                        mode='a+')
         info_log.setLevel('INFO')
-        debug_log.addFilter(SingleLevelFilter(logging.INFO, False))
+        info_log.addFilter(SingleLevelFilter(logging.INFO, False))
         info_log.setFormatter(formatter)
 
         warn_log = logging.FileHandler(os.path.join(self.logdir, 'warn.log'),
                                        mode='a+')
         warn_log.setLevel('WARNING')
-        debug_log.addFilter(SingleLevelFilter(logging.WARNING, False))
+        warn_log.addFilter(SingleLevelFilter(logging.WARNING, False))
         warn_log.setFormatter(formatter)
 
         error_log = logging.FileHandler(os.path.join(self.logdir, 'error.log'),
                                         mode='a+')
         error_log.setLevel('ERROR')
-        debug_log.addFilter(SingleLevelFilter(logging.ERROR, False))
+        error_log.addFilter(SingleLevelFilter(logging.ERROR, False))
         error_log.setFormatter(formatter)
 
         logger.addHandler(all_log)
@@ -241,11 +247,10 @@ class Core:
         providers = {}
 
         self.logger.info("Reading links from providers directory")
-        # We trust links have been generated properly
-        config = ConfigParser.ConfigParser()
         for name in links:
             self.logger.debug("-- Reading %s" % name)
             # We're reading files listed on linksdir, so they must exist!
+            config = ConfigParser.ConfigParser()
             config.read(name)
 
             try:
@@ -288,7 +293,7 @@ class Core:
             ConfigParser. It catches possible exceptions and raises
             RuntimeError if something goes wrong.
 
-            Parameters:
+            Arguments:
                 config: ConfigParser object
                 section: section inside config
                 option: option inside section
@@ -310,3 +315,105 @@ class Core:
         # No other errors should occurr, unless something's terribly wrong
         except ConfigParser.Error as e:
             raise RuntimeError("Unexpected error: %s" % str(e))
+
+    def create_links_file(self, provider):
+        """
+            Public method to create a links file for a provider.
+
+            This should be used by all providers since it writes the links
+            file with the proper format. It backs up the old links file 
+            (if exists) and creates a new one. The name for the links file 
+            is the provider's name in lowercase. It raises a general 
+            exception if something goes wrong while creating the new file.
+            
+            Arguments: 
+                provider: Provider's name. The links file will use this
+                          name in lower case.
+        """
+        linksfile = os.path.join(self.linksdir, provider.lower() + '.links')
+        linksfile_backup = ""
+        self.logger.info("Request to create new %s" % linksfile)
+
+        if os.path.isfile(linksfile):
+            # Backup the old file in case something fails
+            linksfile_backup = linksfile + '.backup'
+            self.logger.info("Backing up %s to %s" 
+                              % (linksfile, linksfile_backup))
+            os.rename(linksfile, linksfile_backup)
+
+        try:
+            # This creates an empty links file (with no links)
+            content = ConfigParser.RawConfigParser()
+            content.add_section('provider')
+            content.set('provider', 'name', provider)
+            content.add_section('linux')
+            content.add_section('windows')
+            content.add_section('osx')
+            with open(linksfile, 'w+') as f:
+                content.write(f)
+                self.logger.info("New %s created" % linksfile)
+        except Exception as e:
+            if linksfile_backup:
+                os.rename(linksfile_backup, linksfile)
+                
+    def add_link(self, provider, operating_system, locale, link):
+        """
+            Public method to add a link to a provider's links file.
+           
+            It uses ConfigParser to add a link into the operating_system
+            section, under the locale option. It check for valid format;
+            the provider's script should use the right format (see design).
+            It raises ValueError in case the operating_system or locale
+            are not supported (see config file for supported ones), or if
+            if there is not a section for the operating_system in the 
+            links file, or if there is no links file for the given provider.
+        """
+        linksfile = os.path.join(self.linksdir, provider.lower() + '.links')
+        
+        # Don't try to add unsupported stuff
+        if locale not in self.supported_locales:
+            self.logger.warning("Trying to add link for unsupported locale: %s"
+                                % locale)
+            raise ValueError("Locale %s not supported at the moment" % locale)
+
+        if operating_system not in self.supported_os:
+            self.logger.warning("Trying to add link for unsupported operating \
+                                system: %s" % operating_system)
+            raise ValueError("Operating system %s not supported at the moment"
+                             % operating_system)
+                             
+        # Check if seems legit format
+        # e.g. https://foo.bar https://foo.bar.asc 111-222-333-444
+        #p = re.compile('^https://\.+\shttps://\.+\s\.+$')
+
+        #if p.match(link):
+        #    self.logger.warning("Trying to add an invalid link: %s" 
+        #                         % link)
+        #    raise ValueError("The link %s doesn't seem to have a valid format"
+        #                      % link)
+        
+        if os.path.isfile(linksfile):
+            content = ConfigParser.RawConfigParser()
+            content.readfp(open(linksfile))
+            # Check if exists and entry for locale; if not, create it
+            try:
+                links = content.get(operating_system, locale)
+                links = links + ",\n" + link
+                content.set(operating_system, locale, links)
+                with open(linksfile, 'w') as f:    
+                    content.write(f)
+                self.logger.info("Link %s added to %s %s in %s"
+                                 % (link, operating_system, locale, provider))
+            except ConfigParser.NoOptionError:
+                content.set(operating_system, locale, link)
+                with open(linksfile, 'w') as f:    
+                    content.write(f)
+                self.logger.info("Link %s added to %s-%s in %s"
+                                 % (link, operating_system, locale, provider))
+            except ConfigParser.NoSectionError:
+                # This shouldn't happen, but just in case
+                self.logger.error("Unknown section %s in links file")
+                raise ValueError("Unknown %s section in links file"
+                                  % operating_system)
+        else:
+            raise ValueError("There is no links file for %s" % provider)



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits