Changeset d3c8759 for fedd


Ignore:
Timestamp:
May 25, 2010 11:15:55 AM (15 years ago)
Author:
Ted Faber <faber@…>
Branches:
axis_example, compt_changes, info-ops, master, version-3.01, version-3.02
Children:
f038da1
Parents:
da2208a
Message:

Wholesale change of IOError to EnvironmentError? for file operations. Lots of
uncaught EnvironmentErrors? were causing spurious error conditions, e.g. on disk
full.

Location:
fedd/federation
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • fedd/federation/allocate_project.py

    rda2208a rd3c8759  
    102102            try:
    103103                read_simple_accessdb(access_db, self.auth, 'allocate')
    104             except IOError, e:
     104            except EnvironmentError, e:
    105105                raise service_error(service_error.internal,
    106106                        "Error reading accessDB %s: %s" % (access_db, e))
    … …  
    132132                self.log.debug("[allocation]: Read state from %s" % \
    133133                        self.state_filename)
    134             except IOError, e:
     134            except EnvironmentError, e:
    135135                self.log.warning(("[allocation]: No saved state: " +\
    136136                        "Can't open %s: %s") % (self.state_filename, e))
    … …  
    154154                f = open(self.state_filename, 'w')
    155155                pickle.dump(self.state, f)
    156             except IOError, e:
     156            except EnvironmentError, e:
    157157                self.log.error("Can't write file %s: %s" % \
    158158                        (self.state_filename, e))
    … …  
    195195        try:
    196196            dnull = open("/dev/null", "w")
    197         except IOError:
     197        except EnvironmentError:
    198198            self.log.warn("[run_cmd]: failed to open /dev/null for redirect")
    199199            dnull = None

  • fedd/federation/deter_impl.py

    rda2208a rd3c8759  
    6464                try:
    6565                    read_simple_accessdb(access_db, self.auth)
    66                 except IOError, e:
     66                except EnvironmentError, e:
    6767                    raise RuntimeError(
    6868                            "Error reading accessDB %s: %s" % (access_db, e))

  • fedd/federation/deter_internal_access.py

    rda2208a rd3c8759  
    220220                f = open(self.state_filename, 'w')
    221221                pickle.dump(self.state, f)
    222             except IOError, e:
     222            except EnvironmentError, e:
    223223                self.log.error("Can't write file %s: %s" % \
    224224                        (self.state_filename, e))
    … …  
    241241                self.log.debug("[read_state]: Read state from %s" % \
    242242                        self.state_filename)
    243             except IOError, e:
     243            except EnvironmentError, e:
    244244                self.log.warning(("[read_state]: No saved state: " +\
    245245                        "Can't open %s: %s") % (self.state_filename, e))
    … …  
    422422                print >>f, alloc_cert
    423423                f.close()
    424             except IOError, e:
     424            except EnvironmentError, e:
    425425                raise service_error(service_error.internal,
    426426                        "Can't open %s/%s : %s" % (self.certdir, aid, e))

  • fedd/federation/dragon_access.py

    rda2208a rd3c8759  
    219219                f = open(self.state_filename, 'w')
    220220                pickle.dump(self.state, f)
    221             except IOError, e:
     221            except EnvironmentError, e:
    222222                self.log.error("Can't write file %s: %s" % \
    223223                        (self.state_filename, e))
    … …  
    240240                self.log.debug("[read_state]: Read state from %s" % \
    241241                        self.state_filename)
    242             except IOError, e:
     242            except EnvironmentError, e:
    243243                self.log.warning(("[read_state]: No saved state: " +\
    244244                        "Can't open %s: %s") % (self.state_filename, e))
    … …  
    414414                print >>f, alloc_cert
    415415                f.close()
    416             except IOError, e:
     416            except EnvironmentError, e:
    417417                raise service_error(service_error.internal,
    418418                        "Can't open %s/%s : %s" % (self.certdir, aid, e))
    … …  
    711711                call(cmd, cwd=self.cli_dir, stdout=f, stderr=f, close_fds=True)
    712712                f.close()
    713             except IOError, e:
     713            except EnvironmentError, e:
    714714                raise service_error(service_error.internal,
    715715                        "Failed to open /dev/null: %s" % e)

  • fedd/federation/emulab_access.py

    rda2208a rd3c8759  
    335335                f = open(self.state_filename, 'w')
    336336                pickle.dump(self.state, f)
    337             except IOError, e:
     337            except EnvironmentError, e:
    338338                self.log.error("Can't write file %s: %s" % \
    339339                        (self.state_filename, e))
    … …  
    362362                self.log.debug("[read_state]: Read state from %s" % \
    363363                        self.state_filename)
    364             except IOError, e:
     364            except EnvironmentError, e:
    365365                self.log.warning(("[read_state]: No saved state: " +\
    366366                        "Can't open %s: %s") % (self.state_filename, e))
    … …  
    566566            cf = open(conffilename, "w")
    567567            os.chmod(conffilename, stat.S_IRUSR | stat.S_IWUSR)
    568         except IOError, e:
     568        except EnvironmentError, e:
    569569            raise service_error(service_error.internal,
    570570                    "Cannot create user configuration data")
    … …  
    572572        try:
    573573            dev_null = open("/dev/null", "a")
    574         except IOError, e:
     574        except EnvironmentError, e:
    575575            self.log.error("export_userconf: can't open /dev/null: %s" % e)
    576576
    … …  
    908908                print >>f, alloc_cert
    909909                f.close()
    910             except IOError, e:
     910            except EnvironmentError, e:
    911911                raise service_error(service_error.internal,
    912912                        "Can't open %s/%s : %s" % (self.certdir, aid, e))
    … …  
    11861186                        (lproj, leid, secretkey_base)
    11871187                f.close()
    1188             except IOError, e:
     1188            except EnvironmentError, e:
    11891189                raise service_error(service_error.internal,
    11901190                        "Can't write protal config %s: %s" % (cfn, e))
    … …  
    12121212                print >>f, "SEERBase: True"
    12131213            f.close()
    1214         except IOError, e:
     1214        except EnvironmentError, e:
    12151215            raise service_error(service_error.internal,
    12161216                    "Cannot write client.conf: %s" %s)
    … …  
    13641364            print >>f, expfile
    13651365            f.close()
    1366         except IOError:
     1366        except EnvironmentError:
    13671367            raise service_error(service_error.internal,
    13681368                    "Cannot write experiment file %s: %s" % (expfn,e))
    … …  
    14821482                        get_url(u, tn, tmpdir, "userconf")
    14831483                        self.log.debug("Got userconf info: %s" % u)
    1484                     except IOError, e:
     1484                    except EnvironmentError, e:
    14851485                        raise service_error(service.error.internal,
    14861486                                "Cannot create temp file for " +
    … …  
    16031603            softdir = "%s/software" % tmpdir
    16041604            os.mkdir(softdir)
    1605         except IOError:
     1605        except EnvironmentError:
    16061606            raise service_error(service_error.internal, "Cannot create tmp dir")
    16071607

  • fedd/federation/experiment_control.py

    rda2208a rd3c8759  
    321321                self.ssh_pubkey = f.read()
    322322                f.close()
    323             except IOError:
     323            except EnvironmentError:
    324324                raise service_error(service_error.internal,
    325325                        "Cannot read sshpubkey")
    … …  
    402402            f = open(self.state_filename, 'w')
    403403            pickle.dump(self.state, f)
    404         except IOError, e:
     404        except EnvironmentError, e:
    405405            self.log.error("Can't write file %s: %s" % \
    406406                    (self.state_filename, e))
    … …  
    452452            self.log.debug("[read_state]: Read state from %s" % \
    453453                    self.state_filename)
    454         except IOError, e:
     454        except EnvironmentError, e:
    455455            self.log.warning("[read_state]: No saved state: Can't open %s: %s"\
    456456                    % (self.state_filename, e))
    … …  
    528528                self.log.warn("[experiment_control] Error parsing access " +\
    529529                        "db %s at line %d" %  (accessdb_file, lineno))
    530         except IOError:
     530        except EnvironmentError:
    531531            raise service_error(service_error.internal,
    532532                    ("Error opening/reading %s as experiment " +\
    … …  
    560560                    self.log.warn("[read_mapdb] Ignored bad line (%d) in " +\
    561561                            "map db: %s %s" % (lineno, line, e))
    562         except IOError, e:
     562        except EnvironmentError, e:
    563563            self.log.warning("[read_mapdb]: No saved map database: Can't " +\
    564564                    "open %s: %s" % (file, e))
    … …  
    571571            self.log.debug("[read_store]: Read store from %s" % \
    572572                    self.store_filename)
    573         except IOError, e:
     573        except EnvironmentError, e:
    574574            self.log.warning("[read_store]: No saved store: Can't open %s: %s"\
    575575                    % (self.state_filename, e))
    … …  
    602602        try:
    603603            self.synch_store.save(self.store_filename)
    604         except IOError, e:
     604        except EnvironmentError, e:
    605605            self.log.error("Can't write file %s: %s" % \
    606606                    (self.store_filename, e))
    … …  
    622622        try:
    623623            trace = open("/dev/null", "w")
    624         except IOError:
     624        except EnvironmentError:
    625625            raise service_error(service_error.internal,
    626626                    "Cannot open /dev/null??");
    … …  
    748748            df, dotname = tempfile.mkstemp()
    749749            dotfile = os.fdopen(df, 'w')
    750         except IOError:
     750        except EnvironmentError:
    751751            raise service_error(service_error.internal,
    752752                    "Failed to open file in genviz")
    … …  
    754754        try:
    755755            dnull = open('/dev/null', 'w')
    756         except IOError:
     756        except EnvironmentError:
    757757            service_error(service_error.internal,
    758758                    "Failed to open /dev/null in genviz")
    … …  
    773773            raise service_error(service_error.internal,
    774774                    "Single endpoint link in vtopo")
    775         except IOError:
     775        except EnvironmentError:
    776776            raise service_error(service_error.internal, "Cannot write dot file")
    777777
    … …  
    14541454        try:
    14551455            os.makedirs(softdir)
    1456         except IOError, e:
     1456        except EnvironmentError, e:
    14571457            raise service_error(
    14581458                    "Cannot create software directory: %s" % e)
    … …  
    15201520        try:
    15211521            tmpdir = tempfile.mkdtemp(prefix="split-")
    1522         except IOError:
     1522        except EnvironmentError:
    15231523            raise service_error(service_error.internal, "Cannot create tmp dir")
    15241524
    … …  
    16071607            tmpdir = tempfile.mkdtemp(prefix="split-")
    16081608            os.mkdir(tmpdir+"/keys")
    1609         except IOError:
     1609        except EnvironmentError:
    16101610            raise service_error(service_error.internal, "Cannot create tmp dir")
    16111611
    … …  
    16351635                    f.write(file_content)
    16361636                    f.close()
    1637                 except IOError:
     1637                except EnvironmentError:
    16381638                    raise service_error(service_error.internal,
    16391639                            "Cannot write temp experiment description")
    … …  
    17481748                f.write('\n'.join(hosts))
    17491749                f.close()
    1750             except IOError, e:
     1750            except EnvironmentError, e:
    17511751                raise service_error(service_error.internal,
    17521752                        "Cannot write hosts file: %s" % e)
    … …  
    17561756                copy_file("%s" % gw_secretkey, "%s/%s" % \
    17571757                        (configdir, gw_secretkey_base))
    1758             except IOError, e:
     1758            except EnvironmentError, e:
    17591759                raise service_error(service_error.internal,
    17601760                        "Cannot copy keyfiles: %s" % e)

  • fedd/federation/fedid.py

    rda2208a rd3c8759  
    170170            else:
    171171                return (None, None)
    172         except IOError, e:
     172        except EnvironmentError, e:
    173173            raise e
    174174    finally:

  • fedd/federation/local_emulab_segment.py

    rda2208a rd3c8759  
    4242        try:
    4343            dnull = open("/dev/null", "w")
    44         except IOError:
     44        except EnvironmentError:
    4545            self.log.debug("[cmd_with_timeout]: failed to open /dev/null " + \
    4646                    "for redirect")
    … …  
    107107        try:
    108108            dev_null = open("/dev/null", "a")
    109         except IOError, e:
     109        except EnvironmentError, e:
    110110            self.log.error("[get_state]: can't open /dev/null: %s" %e)
    111111
    … …  
    149149        try:
    150150            dev_null = open("/dev/null", "a")
    151         except IOError, e:
     151        except EnvironmentError, e:
    152152            self.log.error("[get_state]: can't open /dev/null: %s" %e)
    153153
    … …  
    225225                print >>f, self.null
    226226                f.close()
    227             except IOError, e:
     227            except EnvironmentError, e:
    228228                raise service_error(service_error.internal,
    229229                        "Cannot stage null.tcl: %s" % e.strerror)
    … …  
    266266                        self.copy_file("%s/%s" % (lsoftdir, f),
    267267                                "%s/%s" % (softdir, f))
    268         except IOError, e:
     268        except EnvironmentError, e:
    269269            self.log.error("Error copying file: %s" %e)
    270270            return False

  • fedd/federation/ns2topdl.py

    rda2208a rd3c8759  
    5555            try:
    5656                read_simple_accessdb(access_db, self.auth, 'ns2topdl')
    57             except IOError, e:
     57            except EnvironmentError, e:
    5858                raise service_error(service_error.internal,
    5959                        "Error reading accessDB %s: %s" % (access_db, e))
    … …  
    8686        try:
    8787            tmpdir = tempfile.mkdtemp(prefix="ns2topdl-")
    88         except IOError:
     88        except EnvironmentError:
    8989            raise service_error(service_error.internal, "Cannot create tmp dir")
    9090
    … …  
    108108                    f.write(file_content)
    109109                    f.close()
    110                 except IOError:
     110                except EnvironmentError:
    111111                    raise service_error(service_error.internal,
    112112                            "Cannot write temp experiment description")

  • fedd/federation/protogeni_access.py

    rda2208a rd3c8759  
    261261                f = open(self.state_filename, 'w')
    262262                pickle.dump(self.state, f)
    263             except IOError, e:
     263            except EnvironmentError, e:
    264264                self.log.error("Can't write file %s: %s" % \
    265265                        (self.state_filename, e))
    … …  
    282282                self.log.debug("[read_state]: Read state from %s" % \
    283283                        self.state_filename)
    284             except IOError, e:
     284            except EnvironmentError, e:
    285285                self.log.warning(("[read_state]: No saved state: " +\
    286286                        "Can't open %s: %s") % (self.state_filename, e))
    … …  
    437437            cf = open(conffilename, "w")
    438438            os.chmod(conffilename, stat.S_IRUSR | stat.S_IWUSR)
    439         except IOError, e:
     439        except EnvironmentError, e:
    440440            raise service_error(service_error.internal,
    441441                    "Cannot create user configuration data")
    … …  
    443443        try:
    444444            dev_null = open("/dev/null", "a")
    445         except IOError, e:
     445        except EnvironmentError, e:
    446446            self.log.error("export_userconf: can't open /dev/null: %s" % e)
    447447
    … …  
    596596                print >>f, alloc_cert
    597597                f.close()
    598             except IOError, e:
     598            except EnvironmentError, e:
    599599                raise service_error(service_error.internal,
    600600                        "Can't open %s/%s : %s" % (self.certdir, aid, e))
    … …  
    827827                        secretkey_base
    828828                f.close()
    829             except IOError, e:
     829            except EnvironmentError, e:
    830830                raise service_error(service_error.internal,
    831831                        "Can't write protal config %s: %s" % (cfn, e))
    … …  
    841841                    print >>f, "ExperimentID: %s" % mexp
    842842                    f.close()
    843                 except IOError, e:
     843                except EnvironmentError, e:
    844844                    raise service_error(service_error.internal,
    845845                            "Can't write seer.conf: %s" %e)
    … …  
    858858                    # print >>f, "ExperimentID: %s/%s" % (mproj, meid)
    859859                    f.close()
    860                 except IOError, e:
     860                except EnvironmentError, e:
    861861                    raise service_error(service_error.internal,
    862862                            "Cannot write client.conf: %s" %s)
    … …  
    971971            tmpdir = tempfile.mkdtemp(prefix="access-")
    972972            softdir = "%s/software" % tmpdir
    973         except IOError:
     973        except EnvironmentError:
    974974            raise service_error(service_error.internal, "Cannot create tmp dir")
    975975
    … …  
    10441044                            tf.close()
    10451045                            get_url(u, tn, tmpdir, "userconf")
    1046                         except IOError, e:
     1046                        except EnvironmentError, e:
    10471047                            raise service_error(service.error.internal,
    10481048                                    "Cannot create temp file for " +

  • fedd/federation/proxy_emulab_segment.py

    rda2208a rd3c8759  
    4545        try:
    4646            dev_null = open("/dev/null", "a")
    47         except IOError, e:
     47        except EnvironmentError, e:
    4848            self.log.error("[get_state]: can't open /dev/null: %s" %e)
    4949
    … …  
    9292        try:
    9393            dev_null = open("/dev/null", "a")
    94         except IOError, e:
     94        except EnvironmentError, e:
    9595            self.log.error("[get_mapping]: can't open /dev/null: %s" %e)
    9696
    … …  
    172172                print >>f, self.null
    173173                f.close()
    174             except IOError, e:
     174            except EnvironmentError, e:
    175175                raise service_error(service_error.internal,
    176176                        "Cannot stage tarfile/rpm: %s" % e.strerror)
    … …  
    200200            sf, scriptname = tempfile.mkstemp()
    201201            scriptfile = os.fdopen(sf, 'w')
    202         except IOError:
     202        except EnvironmentError:
    203203            return False
    204204

  • fedd/federation/proxy_protogeni_segment.py

    rda2208a rd3c8759  
    262262                        secretkey_base
    263263                f.close()
    264             except IOError, e:
     264            except EnvironmentError, e:
    265265                raise service_error(service_error.internal,
    266266                        "Can't write protal config %s: %s" % (cfn, e))
    … …  
    280280                        print >>f, "SEERBase: True"
    281281                    f.close()
    282                 except IOError, e:
     282                except EnvironmentError, e:
    283283                    raise service_error(service_error.internal,
    284284                            "Cannot write client.conf: %s" %s)
    … …  
    499499            sf, scriptname = tempfile.mkstemp()
    500500            scriptfile = os.fdopen(sf, 'w')
    501         except IOError:
     501        except EnvironmentError:
    502502            return False
    503503

  • fedd/federation/proxy_segment.py

    rda2208a rd3c8759  
    3838        try:
    3939            dnull = open("/dev/null", "w")
    40         except IOError:
     40        except EnvironmentError:
    4141            self.log.debug("[ssh_file]: failed to open " + \
    4242                    "/dev/null for redirect")
    … …  
    6464        try:
    6565            dnull = open("/dev/null", "w")
    66         except IOError:
     66        except EnvironmentError:
    6767            self.log.debug("[ssh_cmd]: failed to open /dev/null " + \
    6868                    "for redirect")

  • fedd/federation/server.py

    rda2208a rd3c8759  
    145145                    f = open(fname, "rb")
    146146                    size = os.path.getsize(fname)
    147                 except IOError, e:
     147                except EnvironmentError, e:
    148148                    code = 404
    149149                    size = 0

  • fedd/federation/util.py

    rda2208a rd3c8759  
    165165def copy_file(src, dest, size=1024):
    166166    """
    167     Exceedingly simple file copy.  Throws an IOError if there's a problem.
     167    Exceedingly simple file copy.  Throws an EnvironmentError if there's a problem.
    168168    """
    169169    s = open(src,'r')
    … …  
    203203            lf.close()
    204204            ok = True
    205         except IOError, e:
     205        except EnvironmentError, e:
    206206            failed_excpetion = e
    207207            retries += 1
Note: See TracChangeset for help on using the changeset viewer.