Changeset 1082


Ignore:
Timestamp:
08/20/12 22:45:22 (10 years ago)
Author:
joergs
Message:

main function have been integrated to spacecmd upstream (1.8) and therefore removed here. Remaining code adapted to new code base

File:
1 edited

Legend:

Unmodified
Added
Removed
  • people/joerg.steffens/technical/spacecmd/stage.py

    r1019 r1082  
    2525from pprint import pprint
    2626import sys
    27 from StringIO import StringIO
    28 from tempfile import mkdtemp
    29 import difflib
    3027from spacecmd.utils import *
    3128
     
    5350    "unknown":   "?"
    5451}
    55 # when normalizing texts, exclude lines that start with following keywords,
    56 # because they result in differences
    57 # that are not relevant for our staging diffs
    58 _STAGE_TEXT_EXCLUDES=[
    59     # configchannel -> file details
    60     "Revision: ", "Created: ", "Modified: ",
    61     # kickstart
    62     "Org Default: ",
    63     # activation key
    64     "Universal Default: ",
    65 ]
    6652
    6753_DUMP_BASE_DIR="/tmp/spacecmd-stage-dump/"
     
    172158  -s SUB (e.g. application1)'''
    173159
    174 def do_stage_create_skel(self, args, doreturn = False):
     160def do_stage_create_skel(self, args):
    175161    options = [
    176162                Option('-l', '--label', action='store'),
     
    200186            return
    201187
    202     dist        = options.label
    203     arch        = options.arch
    204188    if self.stage_create_skel( options.label, options.arch, options.sub, create=False ):
    205189        self.stage_create_skel( options.label, options.arch, options.sub, create=True )
     
    245229            print " [exists]",
    246230        elif create:
    247             self.do_distribution_create( "--name " + distribution + " --path " + distributionpath + " --base-channel " + base + " --install-type rhel_6" )
     231            self.do_distribution_create( "--name " + distribution + " --path " + distributionpath + " --base-channel " + base + " --install-type " + disttype )
    248232        print
    249233
     
    328312def get_next_stage_name( self, name ):
    329313    current_stage = self.get_stage_from_name( name )
    330     if not current_stage: return
     314    if not current_stage:
     315        return
    331316    next_stage = self.get_next_stage( current_stage )
    332     if not next_stage: return
     317    if not next_stage:
     318        return
    333319    next_stage_name = self.replace_stage_in_name( name, current_stage, next_stage )
    334320    return next_stage_name
    335 
    336 def get_normalized_text( self, text, stage, excludes=_STAGE_TEXT_EXCLUDES ):
    337     """Replace all occurances of stage by the word 'STAGE'"""
    338     normalized_text = []
    339     for line in text:
    340         if not line.startswith( tuple(excludes) ):
    341             normalized_text.append( self.replace_stage_in_name( line, stage, "STAGE" ) )
    342     return normalized_text
    343321
    344322def print_stage_status( self, name, name_next=None, status="unknown", indent="" ):
     
    380358#
    381359
    382 # softwarechannel helper
    383 
    384 def is_softwarechannel( self, name ):
    385     if not name: return
    386     return name in self.do_softwarechannel_list( name, True )
    387 
    388 def check_softwarechannel( self, name ):
    389     if not name:
    390         logging.error( "no softwarechannel label given" )
    391         return False
    392     if not self.is_softwarechannel( name ):
    393         logging.error( "invalid softwarechannel label " + name )
    394         return False
    395     return True
    396 
    397360def get_softwarechannel_childchannel( self, base_channel ):
    398361    result=[]
     
    404367    return result
    405368
    406 
     369   
     370   
    407371# softwarechannel next
    408372
     
    421385    return []
    422386
    423 def do_stage_softwarechannel_next(self, args, doreturn = False):
     387def do_stage_softwarechannel_next(self, args):
    424388    (args, options) = parse_arguments(args)
    425389
     
    438402    # check target name
    439403    if not self.is_softwarechannel(target_name):
    440         if not doreturn:
    441             logging.warning( "a next stage softwarechannel for "+source_name+" ("+target_name+") does not exist" )
    442         return
    443 
    444     if doreturn:
    445         return target_name
    446     else:
    447         print target_name
    448 
    449 
    450 # softwarechannel diff
    451 
    452 def help_stage_softwarechannel_diff(self):
    453     print 'stage_softwarechannel_diff: diff softwarechannel files'
    454     print ''
    455     print 'usage: stage_softwarechannel_diff SOURCE_CHANNEL [TARGET_CHANNEL]'
    456 
    457 def complete_stage_softwarechannel_diff(self, text, line, beg, end):
    458     parts = shlex.split(line)
    459     if line[-1] == ' ': parts.append('')
    460     args = len(parts)
    461 
    462     if args == 2:
    463         return tab_completer(self.do_softwarechannel_list('', True), text)
    464     if args == 3:
    465         return tab_completer(self.do_softwarechannel_list('', True), text)
    466     return []
    467 
    468 def do_stage_softwarechannel_diff(self, args, doreturn = False):
    469     options = []
    470 
    471     (args, options) = parse_arguments(args, options)
    472 
    473     if len(args) != 1 and len(args) != 2:
    474         self.help_stage_softwarechannel_diff()
    475         return
    476 
    477     source_channel = args[0]
    478     if not self.check_softwarechannel( source_channel ): return
    479 
    480     if len(args) == 2:
    481         target_channel = args[1]
    482     else:
    483         target_channel=self.do_stage_softwarechannel_next( source_channel, doreturn = True)
    484     if not self.check_softwarechannel( target_channel ): return
    485 
    486 
    487     source_data = self.dump_softwarechannel( source_channel, normalize=True )
    488     target_data = self.dump_softwarechannel( target_channel, normalize=True )
    489 
    490     result=[]
    491 
    492     for line in difflib.unified_diff( source_data, target_data, source_channel, target_channel ):
    493         if doreturn:
    494             result.append(line)
    495         else:
    496             print line
    497     return result
    498 
    499 
    500 
    501 # softwarechannel sync
    502 
    503 def help_stage_softwarechannel_sync(self):
    504     print 'stage_softwarechannel_sync: sync the (most recent) packages'
    505     print '                            from a software channel to another'
    506     print 'usage: stage_softwarechannel_sync SOURCE_CHANNEL [TARGET_CHANNEL]'
    507 
    508 def complete_stage_softwarechannel_sync(self, text, line, beg, end):
    509     parts = shlex.split(line)
    510     if line[-1] == ' ': parts.append('')
    511     args = len(parts)
    512 
    513 
    514     if args == 2:
    515         return tab_completer(self.do_softwarechannel_list('', True), text)
    516     if args == 3:
    517         return tab_completer(self.do_softwarechannel_list('', True), text)
    518     return []
    519 
    520 def do_stage_softwarechannel_sync(self, args):
    521     options = []
    522 
    523     (args, options) = parse_arguments(args, options)
    524 
    525     if len(args) != 1 and len(args) != 2:
    526         self.help_stage_softwarechannel_sync()
    527         return
    528 
    529     source_channel = args[0]
    530     if len(args) == 2:
    531         target_channel = args[1]
    532     else:
    533         target_channel=self.do_stage_softwarechannel_next( source_channel, doreturn = True)
    534 
    535     logging.info( "syncing packages from softwarechannel "+source_channel+" to "+target_channel )
    536 
    537     # use API call instead of spacecmd function
    538     # to get detailed infos about the packages
    539     # and not just there names
    540     source_packages = self.client.channel.software.listAllPackages(self.session,
    541                                                                source_channel)
    542     target_packages = self.client.channel.software.listAllPackages(self.session,
    543         target_channel)
    544 
    545 
    546     # get the package IDs
    547     source_package_ids = set()
    548     for package in source_packages:
    549         try:
    550             source_package_ids.add(package['id'])
    551         except KeyError:
    552             logging.error( "failed to read key id" )
    553             continue
    554 
    555     target_package_ids = set()
    556     for package in target_packages:
    557         try:
    558             target_package_ids.add(package['id'])
    559         except KeyError:
    560             logging.error( "failed to read key id" )
    561             continue
    562 
    563     print "packages common in both channels:"
    564     for i in ( source_package_ids & target_package_ids ):
    565         print self.get_package_name( i )
    566     print
    567 
    568     source_only = source_package_ids.difference(target_package_ids)
    569     if source_only:
    570         print 'packages to add to channel "' + target_channel + '":'
    571         for i in source_only:
    572             print self.get_package_name( i )
    573         print
    574 
    575 
    576     # check for packages only in target
    577     target_only=target_package_ids.difference( source_package_ids )
    578     if target_only:
    579         print 'packages to remove from channel "' + target_channel + '":'
    580         for i in target_only:
    581             print self.get_package_name( i )
    582         print
    583 
    584     if source_only or target_only:
    585         if not self.user_confirm('Perform these changes to channel ' + target_channel + ' [y/N]:'): return
    586 
    587         self.client.channel.software.addPackages(self.session,
    588                                                 target_channel,
    589                                                 list(source_only) )
    590         self.client.channel.software.removePackages(self.session,
    591                                                 target_channel,
    592                                                 list(target_only) )
     404        logging.debug( "a next stage softwarechannel for "+source_name+" ("+target_name+") does not exist" )
     405        return
     406
     407    return target_name
     408
     409
    593410
    594411####################
     
    597414# configchannel
    598415#
    599 
    600 # configchannel helper
    601 
    602 def is_configchannel( self, name ):
    603     if not name: return
    604     return name in self.do_configchannel_list( name, True )
    605 
    606 def check_configchannel( self, name ):
    607     if not name:
    608         logging.error( "no configchannel given" )
    609         return False
    610     if not self.is_configchannel( name ):
    611         logging.error( "invalid configchannel label " + name )
    612         return False
    613     return True
    614 
    615416
    616417# configchannel next
     
    630431    return []
    631432
    632 def do_stage_configchannel_next(self, args, doreturn = False):
     433def do_stage_configchannel_next(self, args):
    633434    (args, options) = parse_arguments(args)
    634435
     
    647448    # check target name
    648449    if not self.is_configchannel(target_name):
    649         if not doreturn:
    650             logging.warning( "a next stage configchannel for "+source_name+" ("+target_name+") does not exist" )
    651         return
    652 
    653     if doreturn:
    654         return target_name
    655     else:
    656         print target_name
    657 
    658 
    659 # configchannel diff
    660 
    661 def help_stage_configchannel_diff(self):
    662     print 'stage_configchannel_diff: diff between config channels'
    663     print '                          '
    664     print 'usage: stage_configchannel_diff SOURCE_CHANNEL [TARGET_CHANNEL]'
    665 
    666 def complete_stage_configchannel_diff(self, text, line, beg, end):
    667     parts = shlex.split(line)
    668     if line[-1] == ' ': parts.append('')
    669     args = len(parts)
    670 
    671     if args == 2:
    672         return tab_completer(self.do_configchannel_list('', True), text)
    673     if args == 3:
    674         return tab_completer(self.do_configchannel_list('', True), text)
    675     return []
    676 
    677 def do_stage_configchannel_diff(self, args, doreturn = False):
    678     options = []
    679 
    680     (args, options) = parse_arguments(args, options)
    681 
    682     if len(args) != 1 and len(args) != 2:
    683         self.help_stage_configchannel_diff()
    684         return
    685 
    686     source_channel = args[0]
    687     if not self.check_configchannel( source_channel ): return
    688 
    689     if len(args) == 2:
    690         target_channel = args[1]
    691     else:
    692         target_channel=self.do_stage_configchannel_next( source_channel, doreturn = True)
    693     if not self.check_configchannel( target_channel ): return
    694 
    695     source_data = self.dump_configchannel( source_channel, normalize=True )
    696     target_data = self.dump_configchannel( target_channel, normalize=True )
    697 
    698     result=[]
    699     for line in difflib.unified_diff( source_data, target_data, source_channel, target_channel ):
    700         if doreturn:
    701             result.append(line)
    702         else:
    703             print line
    704     return result
    705 
    706 
    707 # configchannel sync
    708 
    709 def help_stage_configchannel_sync(self):
    710     print 'stage_configchannel_sync: sync config files'
    711     print '                          from a config channel to another'
    712     print 'usage: stage_configchannel_sync SOURCE_CHANNEL [TARGET_CHANNEL]'
    713 
    714 def complete_stage_configchannel_sync(self, text, line, beg, end):
    715     parts = shlex.split(line)
    716     if line[-1] == ' ': parts.append('')
    717     args = len(parts)
    718 
    719 
    720     if args == 2:
    721         return tab_completer(self.do_configchannel_list('', True), text)
    722     if args == 3:
    723         return tab_completer(self.do_configchannel_list('', True), text)
    724     return []
    725 
    726 def do_stage_configchannel_sync(self, args, doreturn = False):
    727     options = []
    728 
    729     (args, options) = parse_arguments(args, options)
    730 
    731     if len(args) != 1 and len(args) != 2:
    732         self.help_stage_configchannel_sync()
    733         return
    734 
    735     source_channel = args[0]
    736     if not self.check_configchannel( source_channel ): return
    737 
    738     if len(args) == 2:
    739         target_channel = args[1]
    740     else:
    741         target_channel=self.do_stage_configchannel_next( source_channel, doreturn = True)
    742     if not self.check_configchannel( target_channel ): return
    743 
    744     logging.info( "syncing files from configchannel "+source_channel+" to "+target_channel )
    745 
    746     source_files = set( self.do_configchannel_listfiles( source_channel, doreturn = True ) )
    747     target_files = set( self.do_configchannel_listfiles( target_channel, doreturn = True ) )
    748 
    749     both=source_files & target_files
    750     if both:
    751         print "files common in both channels:"
    752         print "\n".join( both )
    753         print
    754 
    755     source_only=source_files.difference( target_files )
    756     if source_only:
    757         print "files only in source "+source_channel
    758         print "\n".join( source_only )
    759         print
    760 
    761     target_only=target_files.difference( source_files )
    762     if target_only:
    763         print "files only in target "+target_channel
    764         print "\n".join( target_only )
    765         print
    766 
    767     if both:
    768         print "files that are in both channels will be overwritten in the target channel"
    769     if source_only:
    770         print "files only in the source channel will be added to the target channel"
    771     if target_only:
    772         print "files only in the target channel will be deleted"
    773 
    774     if not (both or source_only or target_only):
    775         logging.info( "nothing to do" )
    776         return
    777 
    778     if not self.user_confirm('perform synchronisation [y/N]:'): return
    779 
    780     source_data_list = self.client.configchannel.lookupFileInfo(\
    781                                       self.session, source_channel,
    782                                       list( both  ) + list(source_only) )
    783 
    784 
    785     # TODO: check if this newly available function can be used instead:
    786     # self.configchannel_sync_by_backup_import()
    787     for source_data in source_data_list:
    788         if source_data.get('type') == 'file' or source_data.get('type') == 'directory':
    789             if source_data.get('contents') and not source_data.get('binary'):
    790                 contents = source_data.get('contents').encode('base64')
    791             else:
    792                 contents = source_data.get('contents')
    793             target_data = {
    794                 'contents':                 contents,
    795                 'contents_enc64':           True,
    796                 'owner':                    source_data.get('owner'),
    797                 'group':                    source_data.get('group'),
    798                 #'permissions':              str(source_data.get('permissions')),
    799                 'permissions':              source_data.get('permissions_mode'),
    800                 'selinux_ctx':              source_data.get('selinux_ctx'),
    801                 'macro-start-delimiter':    source_data.get('macro-start-delimiter'),
    802                 'macro-end-delimiter':      source_data.get('macro-end-delimiter'),
    803             }
    804             for k,v in target_data.items():
    805                 if not v:
    806                     del target_data[k]
    807             logging.debug( source_data.get('path') + ": " + str(target_data) )
    808             self.client.configchannel.createOrUpdatePath(self.session,
    809                                                          target_channel,
    810                                                          source_data.get('path'),
    811                                                          source_data.get('type') == 'directory',
    812                                                          target_data)
    813 
    814         elif source_data.get('type') == 'symlink':
    815             target_data = {
    816                 'target_path':  source_data.get('target_path'),
    817                 'selinux_ctx':  source_data.get('selinux_ctx'),
    818             }
    819             logging.debug( source_data.get('path') + ": " + str(target_data) )
    820             self.client.configchannel.createOrUpdateSymlink(self.session,
    821                                                             target_channel,
    822                                                             source_data.get('path'),
    823                                                             target_data )
    824 
    825         else:
    826             logging.warning( "unknown file type " + source_data.type )
    827 
    828 
    829     # removing all files from target channel that did not exist on source channel
    830     if target_only:
    831         self.do_configchannel_removefiles( target_channel + " " + " ".join(target_only) )
     450        logging.debug( "a next stage configchannel for "+source_name+" ("+target_name+") does not exist" )
     451        return
     452    return target_name
    832453
    833454
     
    837458# kickstart
    838459#
    839 
    840 # kickstart helper
    841 
    842 def is_kickstart( self, name ):
    843     if not name: return
    844     return name in self.do_kickstart_list( name, True )
    845 
    846 def check_kickstart( self, name ):
    847     if not name:
    848         logging.error( "no kickstart label given" )
    849         return False
    850     if not self.is_kickstart( name ):
    851         logging.error( "invalid kickstart label " + name )
    852         return False
    853     return True
    854 
    855460
    856461# kickstart next
     
    870475    return []
    871476
    872 def do_stage_kickstart_next(self, args, doreturn = False):
     477def do_stage_kickstart_next(self, args):
    873478    (args, options) = parse_arguments(args)
    874479
     
    887492    # check target name
    888493    if not self.is_kickstart(target_name):
    889         if not doreturn:
    890             logging.warning( "a next stage kickstart for "+source_name+" ("+target_name+") does not exist" )
    891         return
    892 
    893     if doreturn:
    894         return target_name
    895     else:
    896         print target_name
    897 
    898 
    899 # kickstart diff
    900 
    901 def help_stage_kickstart_diff(self):
    902     print 'stage_kickstart_diff: diff kickstart files'
    903     print ''
    904     print 'usage: stage_kickstart_diff SOURCE_CHANNEL [TARGET_CHANNEL]'
    905 
    906 def complete_stage_kickstart_diff(self, text, line, beg, end):
    907     parts = shlex.split(line)
    908     if line[-1] == ' ': parts.append('')
    909     args = len(parts)
    910 
    911     if args == 2:
    912         return tab_completer(self.do_kickstart_list('', True), text)
    913     if args == 3:
    914         return tab_completer(self.do_kickstart_list('', True), text)
    915     return []
    916 
    917 def do_stage_kickstart_diff(self, args, doreturn = False):
    918     options = []
    919 
    920     (args, options) = parse_arguments(args, options)
    921 
    922     if len(args) != 1 and len(args) != 2:
    923         self.help_stage_kickstart_diff()
    924         return
    925 
    926     source_channel = args[0]
    927     if not self.check_kickstart( source_channel ): return
    928 
    929     if len(args) == 2:
    930         target_channel = args[1]
    931     else:
    932         target_channel=self.do_stage_kickstart_next( source_channel, doreturn = True)
    933     if not self.check_kickstart( target_channel ): return
    934 
    935 
    936     source_data = self.dump_kickstart( source_channel, normalize=True )
    937     target_data = self.dump_kickstart( target_channel, normalize=True )
    938 
    939     result=[]
    940     for line in difflib.unified_diff( source_data, target_data, source_channel, target_channel ):
    941         if doreturn:
    942             result.append(line)
    943         else:
    944             print line
    945     return result
    946 
    947 
     494        logging.debug( "a next stage kickstart for "+source_name+" ("+target_name+") does not exist" )
     495        return
     496    return target_name
    948497
    949498####################
     
    952501# activationkey
    953502#
    954 
    955 # activationkey helper
    956 
    957 def is_activationkey( self, name ):
    958     if not name: return
    959     return name in self.do_activationkey_list( name, True )
    960 
    961 def check_activationkey( self, name ):
    962     if not name:
    963         logging.error( "no activationkey label given" )
    964         return False
    965     if not self.is_activationkey( name ):
    966         logging.error( "invalid activationkey label " + name )
    967         return False
    968     return True
    969 
    970503
    971504# activationkey next
     
    985518    return []
    986519
    987 def do_stage_activationkey_next(self, args, doreturn = False):
     520def do_stage_activationkey_next(self, args):
    988521    (args, options) = parse_arguments(args)
    989522
     
    1002535    # check target name
    1003536    if not self.is_activationkey(target_name):
    1004         if not doreturn:
    1005             logging.warning( "a next stage activationkey for "+source_name+" ("+target_name+") does not exist" )
    1006         return
    1007 
    1008     if doreturn:
    1009         return target_name
    1010     else:
    1011         print target_name
    1012 
    1013 
    1014 # activationkey diff
    1015 
    1016 def help_stage_activationkey_diff(self):
    1017     print 'stage_activationkeyt_diff: diff activationkeys'
    1018     print ''
    1019     print 'usage: stage_activationkey_diff SOURCE_ACTIVATIONKEY [TARGET_ACTIVATIONKEY]'
    1020 
    1021 def complete_stage_activationkey_diff(self, text, line, beg, end):
    1022     parts = shlex.split(line)
    1023     if line[-1] == ' ': parts.append('')
    1024     args = len(parts)
    1025 
    1026 
    1027     if args == 2:
    1028         return tab_completer(self.do_activationkey_list('', True), text)
    1029     if args == 3:
    1030         return tab_completer(self.do_activationkey_list('', True), text)
    1031     return []
    1032 
    1033 def do_stage_activationkey_diff(self, args, doreturn = False):
    1034     options = []
    1035 
    1036     (args, options) = parse_arguments(args, options)
    1037 
    1038     if len(args) != 1 and len(args) != 2:
    1039         self.help_stage_activationkey_diff()
    1040         return
    1041 
    1042     source_channel = args[0]
    1043     if not self.check_activationkey( source_channel ): return
    1044 
    1045     if len(args) == 2:
    1046         target_channel = args[1]
    1047     else:
    1048         target_channel=self.do_stage_activationkey_next( source_channel, doreturn = True)
    1049     if not self.check_activationkey( target_channel ): return
    1050 
    1051 
    1052     source_data = self.dump_activationkey( source_channel, normalize=True )
    1053     target_data = self.dump_activationkey( target_channel, normalize=True )
    1054 
    1055     result=[]
    1056     for line in difflib.unified_diff( source_data, target_data, source_channel, target_channel ):
    1057         if doreturn:
    1058             result.append(line)
    1059         else:
    1060             print line
    1061     return result
    1062 
    1063 
     537        logging.debug( "a next stage activationkey for "+source_name+" ("+target_name+") does not exist" )
     538        return
     539    return target_name
    1064540
    1065541
     
    1081557    if line[-1] == ' ': parts.append('')
    1082558    args = len(parts)
    1083 
    1084559
    1085560    if args == 2:
     
    1115590def check_stage_softwarechannel_status( self, name, indent="" ):
    1116591    status="unknown"
    1117     name_next = self.do_stage_softwarechannel_next( name, doreturn=True )
     592    name_next = self.do_stage_softwarechannel_next( name )
    1118593    if name_next:
    1119         if self.do_stage_softwarechannel_diff( name + " " + name_next, doreturn=True ):
     594        if self.do_softwarechannel_diff( name + " " + name_next ):
    1120595            status="modified"
    1121596        else:
     
    1137612def check_stage_configchannels_status( self, name, indent="" ):
    1138613    status="unknown"
    1139     name_next = self.do_stage_configchannel_next( name, doreturn=True )
     614    name_next = self.do_stage_configchannel_next( name )
    1140615    if name_next:
    1141         if self.do_stage_configchannel_diff( name + " " + name_next, doreturn=True ):
     616        if self.do_configchannel_diff( name + " " + name_next ):
    1142617            status="modified"
    1143618        else:
     
    1160635def check_stage_kickstarts_status( self, name, indent="" ):
    1161636    status="unknown"
    1162     name_next = self.do_stage_kickstart_next( name, doreturn=True )
     637    name_next = self.do_stage_kickstart_next( name )
    1163638    if name_next:
    1164         if self.do_stage_kickstart_diff( name + " " + name_next, doreturn=True ):
     639        if self.do_kickstart_diff( name + " " + name_next ):
    1165640            status="modified"
    1166641        else:
     
    1183658def check_stage_activationkey_status( self, name, indent="" ):
    1184659    status="unknown"
    1185     name_next = self.do_stage_activationkey_next( name, doreturn=True )
     660    name_next = self.do_stage_activationkey_next( name )
    1186661    if name_next:
    1187         if self.do_stage_activationkey_diff( name + " " + name_next, doreturn=True ):
     662        if self.do_activationkey_diff( name + " " + name_next ):
    1188663            status="modified"
    1189664        else:
     
    1232707    self.stage = stage
    1233708
    1234 
    1235709    if len(args) == 2:
    1236710        outputpath_base = datetime.now().strftime(os.path.expanduser(args[1]))
     
    1248722    self.dump_activationkeys( outputpath_base + "/activationkey/" )
    1249723
    1250 
    1251 
    1252 
     724   
     725   
    1253726def dump_softwarechannels(self, basedir):
    1254727    logging.info( "softwarechannel" )
     
    1265738            for child_channel in self.get_softwarechannel_childchannel( base_channel ):
    1266739                logging.info( "    " + child_channel )
    1267                 packages = self.dump_softwarechannel( child_channel, onlyLastestPackages=False, normalize=True )
     740                packages = self.dump_softwarechannel( child_channel )
    1268741                self.dump( base_channel_dir + '/' + self.get_common_name(child_channel), packages )
    1269742
    1270 def dump_softwarechannel(self, name, onlyLastestPackages=True, normalize=False):
    1271     if onlyLastestPackages:
    1272         content = self.do_softwarechannel_listallpackages( name, doreturn=True )
    1273     else:
    1274         content = self.do_softwarechannel_listallpackages( name, doreturn=True )
    1275     return content
    1276 
    1277 def dump_configchannel_filedetails(self, name, filename, normalize=False):
    1278     # redirect stdout to string.
    1279     # to be able to reuse the existing do_activationkey_details function
    1280     old_stdout=sys.stdout
    1281     output=StringIO()
    1282     sys.stdout=output
    1283     self.do_configchannel_filedetails( name +" "+ filename )
    1284     sys.stdout=old_stdout
    1285     content=output.getvalue().split("\n")
    1286     output.close()
    1287 
    1288     if normalize:
    1289         stage = self.get_stage_from_name( name )
    1290         content=self.get_normalized_text( content, stage )
    1291     return content
    1292 
    1293 def dump_configchannel(self, name, normalize=False):
    1294     # redirect stdout to string.
    1295     # to be able to reuse the existing do_activationkey_details function
    1296     old_stdout=sys.stdout
    1297     output=StringIO()
    1298     sys.stdout=output
    1299     self.do_configchannel_details( name )
    1300     sys.stdout=old_stdout
    1301     content=output.getvalue().split("\n")
    1302     output.close()
    1303 
    1304     for filename in self.do_configchannel_listfiles(name, True):
    1305         content = content + self.dump_configchannel_filedetails(name, filename, normalize=True)
    1306 
    1307     if normalize:
    1308         stage = self.get_stage_from_name( name )
    1309         content=self.get_normalized_text( content, stage )
    1310 
    1311     return content
    1312 
    1313 
     743               
     744               
    1314745def dump_configchannels(self, basedir):
    1315746    logging.info( "configchannel" )
     
    1319750        if self.is_current_stage( name ):
    1320751            logging.info( "  " + name )
    1321             dir = basedir + self.get_common_name(name)
    1322             self.do_configchannel_backup( name+" "+dir )
    1323 
    1324 
    1325 def dump_kickstart_content(self, name, normalize=False):
    1326     content = self.client.kickstart.profile.downloadRenderedKickstart(\
    1327                                                 self.session, name ).split("\n")
    1328     stage = self.get_stage_from_name( name )
    1329     if normalize:
    1330         content=self.get_normalized_text( content, stage )
    1331     return content
    1332 
    1333 def dump_kickstart_details(self, name, normalize=False):
    1334     # redirect stdout to string.
    1335     # to be able to reuse the existing do_activationkey_details function
    1336     old_stdout=sys.stdout
    1337     output=StringIO()
    1338     sys.stdout=output
    1339     self.do_kickstart_details( name )
    1340     sys.stdout=old_stdout
    1341     content=output.getvalue().split("\n")
    1342     output.close()
    1343 
    1344     if normalize:
    1345         stage = self.get_stage_from_name( name )
    1346         content=self.get_normalized_text( content, stage )
    1347 
    1348     return content
    1349 
    1350 def dump_kickstart(self, name, normalize=False):
    1351     return dump_kickstart_details(self, name, normalize=normalize)
    1352 
    1353 
    1354 def dump_kickstarts(self, basedir, doreturn = False):
     752            directory = basedir + self.get_common_name(name)
     753            self.do_configchannel_backup( name+" "+directory )   
     754
     755           
     756def dump_kickstarts(self, basedir):
    1355757    logging.info( "kickstart" )
    1356758    kickstarts = self.client.kickstart.listKickstarts(self.session)
     
    1361763            logging.info( "  " + name )
    1362764            dir = basedir + self.get_common_name(name)
    1363             content = self.dump_kickstart( name, normalize=True )
    1364             if doreturn:
    1365                 return content
    1366             else:
    1367                 # dump kickstart details and ks file content.
    1368                 # use  separate files
    1369                 self.dump( dir + '/' + self.get_common_name(name), content )
    1370                 self.dump( dir + '/' + self.get_common_name(name) + ".content", dump_kickstart_content(self, name, normalize=True) )
    1371 
    1372 
    1373 def dump_activationkey(self, name, normalize=False):
    1374     # redirect stdout to string.
    1375     # to be able to reuse the existing do_activationkey_details function
    1376     old_stdout=sys.stdout
    1377     output=StringIO()
    1378     sys.stdout=output
    1379     self.do_activationkey_details( name )
    1380     sys.stdout=old_stdout
    1381     content=output.getvalue().split("\n")
    1382     output.close()
    1383 
    1384     if normalize:
    1385         stage = self.get_stage_from_name( name )
    1386         content=self.get_normalized_text( content, stage )
    1387 
    1388     return content
    1389 
     765            content = self.dump_kickstart( name )
     766            # dump kickstart details and ks file content.
     767            # use  separate files
     768            self.dump( dir + '/' + self.get_common_name(name), content )
     769            #self.dump( dir + '/' + self.get_common_name(name) + ".content", dump_kickstart_content(self, name) )
    1390770
    1391771
     
    1398778            logging.info( "  " + name )
    1399779
    1400             content = self.dump_activationkey( name, normalize=True)
     780            content = self.dump_activationkey( name )
    1401781
    1402782            dir = basedir + self.get_common_name(name)
    1403783            self.dump( dir + '/' + self.get_common_name(name), content )
    1404784
     785           
    1405786# vim:ts=4:expandtab:
Note: See TracChangeset for help on using the changeset viewer.