def update(self, args, opts): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - """ updates file or directories @type args: sequence @param args: sequence of files or directories to update @rtype: string @return: returns output of the cvs commands """ if not self.cvsup: print('CVS Archive "%s" is down' % self.root, file=oss.stderr) return "" if not args: return oss.r(self.exe + ' up -d', '|') res = [] for f in args: if oss.IsDir(f): oss.pushcd(f) res.append(oss.r(self.exe + ' up -d', '|')) oss.popcd() else: res.append(oss.r(self.exe + ' up ' + f, '|')) return '\n'.join(res)
def check(self, args=None, opts=None): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - """ checks files or directories @type args: sequence @param args: sequence of files or directories to check """ if not self.cvsup: print('CVS Archive "%s" is down' % self.root, file=oss.stderr) return '' res = [] if not args: for s in oss.r(self.exe + '-qn up -A ', '|').split('\n'): if not s.startswith('?'): res.append(s) return '\n'.join(res) for f in args: if oss.IsDir(f): if oss.pushcd(f): for s in oss.r(self.exe + '-qn up -A ', '|').split('\n'): if not s.startswith('?'): res.append(s) oss.popcd() else: res.append(oss.r(self.exe + '-qn up -A ' + f, '|')) return '\n'.join(res)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [], usage) cvsdwn = not CvsRootCheck() for f in oss.paths(args): ext = oss.splitext(f).lower() opts = '-kb' if ext in BinExts else '' if cvsdwn: otf = file('CVS/offline', 'a') print >> otf, 'add ' + opts + ' ' + f otf.close() else: if oss.exists('CVS/offline'): inf = file('CVS/offline') for cmd in inf: oss.r('cvs.exe ' + cmd) inf.close() oss.rm('CVS/offline') oss.r('cvs.exe add ' + opts + ' ' + f) oss.exit(0)
def ci(self, args, opts): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - """ checks the files in. if directories are specified, goes there first @type msg: string @param msg: check in message @type args: sequence @param args: sequence of files or directories to check in @rtype: string @return: returns output of the cvs commands """ if not self.cvsup: print('CVS Archive "%s" is down' % self.root, file=oss.stderr) return "" msg = opts.get('msg', '--') if not msg: msg = '--' if not args: #print(self.exe + ' ci -m "%s"' % msg) return oss.r(self.exe + ' ci -m "%s"' % msg, '|') #return oss.r(self.exe + ' ci -m "%s"' % msg) res = [] for f in args: if oss.IsDir(f): oss.pushcd(f) res.append(oss.r(self.exe + ' ci -m "%s"' % msg, '|')) oss.popcd() else: res.append(oss.r(self.exe + ' ci -m "%s" %s' % (msg, f), '|')) return '\n'.join(res)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [], usage) cvsdwn = not CvsRootCheck() for f in oss.paths(args): ext = oss.splitext(f).lower() opts = '-kb' if ext in BinExts else '' if cvsdwn: otf = file('CVS/offline', 'a') print >> otf, 'add ' + opts + ' ' + f otf.close() else: if oss.exists('CVS/offline'): inf = file('CVS/offline') for cmd in inf: oss.r('cvs.exe ' + cmd) inf.close() oss.rm('CVS/offline') oss.r('cvs.exe add ' + opts + ' ' + f) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- """ usage: """ print(argv) args, opts = oss.gopt(argv[1:], [], [], main.__doc__ + __doc__) la = len(args) print(la) print(args) if not (0 < la < 3): oss.usage( 1, "usage: cvt_flv_mp3.py <file_name.flv> [<output_file_name.mp3>]") elif la == 2: pth, fn, ext = oss.splitFilename(args[0]) if not pth: pth = '.' infn = fn + '.flv' print(infn) pth, fn, ext = oss.splitFilename(args[1]) if not pth: pth = '.' outfn = pth + '\\' + fn + '.mp3' else: pth, fn, ext = oss.splitFilename(args[0]) if not pth: pth = '.' infn = fn + '.flv' outfn = pth + '\\' + fn + '.mp3' print("Pulling '%s' from '%s'" % (outfn, infn)) oss.r(FFMPEG % (infn, outfn)) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [('r', 'rmtport'), ('l', 'locport')], usage) if opts.locport: locport = int(opts.locport) else: locport = random.randint(5905, 5930) display = locport - 5900 rmtport = 5901 if len(args) != 1: usage(1) if ':' in args[0]: mach, rp = args[0].split(':') rmtport = int(rp) + 5900 else: mach = args[0] if opts.rmtport: rmtport = int(opts.rmtport) t = threading.Thread(target=makeTunnel, args=(locport, mach, rmtport)) t.setDaemon(True) t.start() time.sleep(5) oss.cd("C:/Program Files/tightvnc/") oss.r('vncviewer.exe %s:%d' % ('localhost', display)) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- """ usage: """ print(argv) args, opts = oss.gopt(argv[1:], [], [], main.__doc__ + __doc__) la = len(args) print(la) print(args) if not (0 < la < 3): oss.usage(1, "usage: cvt_flv_mp3.py <file_name.flv> [<output_file_name.mp3>]") elif la == 2: pth, fn, ext = oss.splitFilename(args[0]) if not pth: pth = '.' infn = fn + '.flv' print(infn) pth, fn, ext = oss.splitFilename(args[1]) if not pth: pth = '.' outfn = pth + '\\' + fn + '.mp3' else: pth, fn, ext = oss.splitFilename(args[0]) if not pth: pth = '.' infn = fn + '.flv' outfn = pth + '\\' + fn + '.mp3' print("Pulling '%s' from '%s'" % (outfn, infn)) oss.r(FFMPEG % (infn, outfn)) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [], usage) for fn in args: print fn oss.r('crypt <%s >tt.zip' % (fn)) oss.r('python C:/bin/zippy.py tt.zip') oss.rm('tt.zip')
def updateOffline(self): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - """ if some offline operations were queued, execute them if online """ if self.cvsup and oss.exists('CVS/offline'): inf = file('CVS/offline') for cmd in inf: oss.r(self.exe + cmd) inf.close() oss.rm('CVS/offline') return True
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [], usage) for fn in args: if not oss.exists(fn): usage(1, "%s does not exist" % fn) oss.r('python C:/bin/zippy.py -z -c tt.zip %s/*' % fn) oss.r('crypt <tt.zip > %s.sec' % (fn)) oss.rm('tt.zip')
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [], usage) if not args: args = ['.'] for dir in args: oss.cd(dir) oss.r('cvs.exe up -d') oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- """ usage: cff -i | --ignore : ignore this file (or filespec) -l | --ignorelist : dump list of ignored files -a | --add : add the files to CVS list the files that have NOT been checked into the CVS archive """ args, opts = oss.gopt(argv[1:], [('l', 'ignorelist'), ('a', 'add')], [], [], [('i', 'ignore')], main.__doc__) if oss.exists('CVS'): if opts.ignore: with open(".cffignore", "a") as igf: for i in opts.ignore: print(i, file=igf) oss.exit(0) if opts.add is not None: lst = doDir() for l in lst: print('cvs add ' + oss.basename(l)) oss.r('cvs add ' + oss.basename(l)) oss.exit(0) if opts.ignorelist is not None: lst = list(mkcvs.IGNORE_PATTERNS) with open(".cffignore") as igf: for line in igf: line = line[:-1] lst.append(line) print(lst) lst = doDir() for l in lst: print(l) else: print('montone') pth = oss.findFilePathUp('_MTN') if pth: lst = oss.r('mtn ls unknown', '|').split('\n') pwd = oss.normpath(oss.pwd()) for i in lst: if (pth + i).startswith(pwd): print(i) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [], usage) if not args: args = ['.'] for dir in args: oss.cd(dir) oss.r('cvs.exe up -d') oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- """ usage: cff -i | --ignore : ignore this file (or filespec) -l | --ignorelist : dump list of ignored files -a | --add : add the files to CVS list the files that have NOT been checked into the CVS archive """ args, opts = oss.gopt(argv[1:], [('l', 'ignorelist'), ('a', 'add')], [], [], [('i', 'ignore')], main.__doc__) if oss.exists('CVS'): if opts.ignore: with open(".cffignore", "a") as igf: for i in opts.ignore: print(i, file=igf) oss.exit(0) if opts.add is not None: lst = doDir() for l in lst: print('cvs add ' + oss.basename(l)) oss.r('cvs add ' + oss.basename(l)) oss.exit(0) if opts.ignorelist is not None: lst = list(mkcvs.IGNORE_PATTERNS) with open(".cffignore") as igf: for line in igf: line = line[:-1] lst.append(line) print(lst) lst = doDir() for l in lst: print(l) else: print('montone') pth = oss.findFilePathUp('_MTN') if pth: lst = oss.r('mtn ls unknown', '|').split('\n') pwd = oss.normpath(oss.pwd()) for i in lst: if (pth + i).startswith(pwd): print(i) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [('m', 'msg'), ('d', 'db')], usage) options = "--db " + opts.db if opts.db else '' if args and args[0] == 'ci': f = oss.r('mtn.exe %s ci -m "%s"' % (options, args[2]), '<') f.write('kibsop)') f.close() else: oss.r("mtn.exe " + options + ' ' + ' '.join(args)) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- """ usage: myedit.py <files> [<files> ...] frontend to myedit """ args, opts = oss.gopt(argv[1:], [], [], main.__doc__ + __doc__) ff = [oss.canonicalPath(arg) for arg in args] for f in ff: if not oss.exists(f): oss.touch(f) oss.r('C:/python26/python.exe C:/home/chrish/work/myedit/myedit.py -X -s ' + ' '.join(ff)) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [('m', 'msg'), ('d', 'db')], usage) options = "--db " + opts.db if opts.db else '' if args and args[0] == 'ci': f = oss.r('mtn.exe %s ci -m "%s"' % (options, args[2]), '<') f.write('kibsop)') f.close() else: oss.r("mtn.exe " + options + ' ' + ' '.join(args)) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [('m', 'msg')], usage) if opts.msg is None: opts.msg = "" if not args: args = ['.'] for dir in args: oss.cd(dir) oss.r('cvs.exe ci -m "%s"' % opts.msg) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [], [('m', 'msg')], usage) if opts.msg is None: opts.msg = "" if not args: args = ['.'] for dir in args: oss.cd(dir) oss.r('cvs.exe ci -m "%s"' % opts.msg) oss.exit(0)
def getWNetworks(nic): #------------------------------------------------------------------------------- n = [] s = oss.r("%s %s scan" % (IWLIST, nic), '|') state = 0 net = None for line in s.split('\n'): line = line.strip() if state == 0: if line.find('Cell') == 0: net = WNet() state = 1 elif state == 1: if line.find('Encryption') == 0: net.encrypt = line.split(':')[1] elif line.find('Quality') == 0: t = line.split()[0] net.qual = t.split('=')[1] elif line.find('ESSID') == 0: name = line.split(':')[1][1:-1] if name: net.name = name n.append(net) elif line.find('Mode') == 0: state = 0 return n
def getWNetworks(nic): #------------------------------------------------------------------------------- n = [] s = oss.r("%s %s scan" % (IWLIST, nic), '|') state = 0 net = None for line in s.split('\n'): line = line.strip() if state == 0: if line.find('Cell') == 0: net = WNet() state = 1 elif state == 1: if line.find('Encryption') == 0: net.encrypt = line.split(':')[1] elif line.find('Quality') == 0: t = line.split()[0] net.qual = t.split('=')[1] elif line.find('ESSID') == 0: name = line.split(':')[1][1:-1] if name: net.name = name n.append(net) elif line.find('Mode') == 0: state = 0 return n
def create(fn, force = False, python="python.exe"): #------------------------------------------------------------------------------- if not oss.exists(fn): return oname = oss.replaceExt(fn, '.bat') if not force and oss.exists(oname): print(oname, "already exists") return True with open(oname, 'w') as otf: print("""echo off\n%s C:\\bin\\%s %%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9""" % (python, fn), file=otf) oss.r("cvs add %s" % oname) oss.r('cvs ci -m "new file" %s' % oname) return True
def decvs(self, args, opts): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - for f in oss.ls(): bf = oss.basename(f) if bf.lower() == 'cvs': print('removing:', f) oss.r('rm -rf cvs') continue if self.ignoreFile(bf): continue if oss.IsDir(bf): oss.pushcd(bf) self.decvs(args, opts) oss.popcd()
def main(argv): #------------------------------------------------------------------------------- """ usage: uncvs [<dir>] Remove CVS from a directory if specified, else the current directory """ args, opts = oss.gopt(argv[1:], [], [], main.__doc__) if args: oss.cd(args[0]) for dd in oss.find('.', 'CVS'): if oss.exists(dd + '/ROOT'): print("Removing:", dd) oss.r("rm -rf " + dd) oss.exit(0)
def _issueCmd(self, cmd): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - """ used for functions that can effectively work offline @type cmd: string @param cmd: the command and command line to be passed to cvs """ if self.cvsup: print(self.exe + cmd) oss.r(self.exe + cmd) else: try: otf = file('CVS/offline', 'a') otf.write(cmd + '\n') otf.close() except IOError: print("No project for offline", file=oss.stderr)
def makeTunnel(loc, mach, rmt): #------------------------------------------------------------------------------- idx = 1 while 1: st = time.time() print 'Connecting local port %d to %s:%d' % (loc, mach, rmt) oss.r( 'plink -l chrish -pw kibsop) -N -L %d:%s:%d compflu-02.hpl.hp.com ' % (loc, mach, rmt)) if st + 60 < time.time(): time.sleep(10 * idx) idx += 1 if idx > 6: idx = 1 else: idx = 1
def create(fn, force=False, python="python.exe"): #------------------------------------------------------------------------------- if not oss.exists(fn): return oname = oss.replaceExt(fn, '.bat') if not force and oss.exists(oname): print(oname, "already exists") return True with open(oname, 'w') as otf: print( """echo off\n%s C:\\bin\\%s %%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9""" % (python, fn), file=otf) oss.r("cvs add %s" % oname) oss.r('cvs ci -m "new file" %s' % oname) return True
def main(argv): #------------------------------------------------------------------------------- args, opts = oss.gopt(argv[1:], [('d', 'delete')], [], usage) la = len(args) if la < 1: usage('insufficient arguments') tgt = args[0] if la == 1: if opts.delete: rc = oss.r('linkd.exe "%s" /D' % tgt) else: rc = oss.r('linkd.exe "%s" "%s"' % (oss.basename(tgt), tgt)) else: rc = oss.r('linkd.exe "%s" "%s"' % (args[1], tgt)) oss.exit(rc)
def run(self, fn, force=False): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - oss.r('indent1.exe ' + self.indentOptions + ' ' + fn) return bfn = self.makeBU(fn, force) inf = open(bfn, 'rU') otf = open(fn, 'w') ol2 = ol1 = ls = None for line in inf: ol2 = ol1 ol1 = ls ls = line.strip() if not ls: otf.write('\n') continue if ls.startswith('if') or ls.startswith('for') or ls.startswith( 'while') or ls.startswith('switch'): if ol1: otf.write('\n') otf.write(line) elif ls.endswith('('): if line[0] not in [' '] or (len(ls.split()) > 1 and '=' not in line): if ol2: otf.write('\n') if ol1: otf.write('\n') otf.write('//' + ('-' * 78) + '\n') otf.write(line) otf.write('//' + ('-' * 78) + '\n') elif ls.startswith('break'): otf.write(line) otf.write('\n') else: otf.write(line)
def main(argv): #------------------------------------------------------------------------------- """ usage: cf.py [options] options: -n | --nocheck : don't check for CVSROOT show files in CVS/MTN that are changed in local directory """ args, opt = oss.gopt(oss.argv[1:], [('n', 'nocheck')], [], main.__doc__) if oss.exists('CVS'): if opt.nocheck is None: CvsRootCheck() if not args: oss.r(r'C:\bin\cvs.exe -qn up -A | C:\mksnt\fgrep.exe -v "?"') else: for dir in args: oss.cd(dir) oss.r(r'C:\bin\cvs.exe -qn up -A | C:\mksnt\fgrep.exe -v "?"') elif oss.findFilePathUp('_MTN'): oss.r('mtn status') #print '\nunknown files:' #oss.r('mtn ls unknown') oss.exit(0)
def main(argv): #------------------------------------------------------------------------------ args, opts = oss.gopt(argv[1:], [], [], "") if not args: args = machs.keys() for m in args: if m not in machs: print "unknown machine", m continue print "Opening", m session = oss.r("qdbus org.kde.konsole /Konsole newSession", '$').strip() s = oss.r("qdbus org.kde.konsole /Sessions/%s setTitle 1 %s" % (session, m), '|') if s.strip(): print s.rstrip() s = oss.r('qdbus org.kde.konsole /Sessions/%s sendText "ssh %s"' % (session, m), '|') if s.strip(): print s.rstrip() s = oss.r('~/bin/qdsendnl %s' % session, '|') if s.strip(): print s.rstrip() for cmd in machs[m]: if cmd: s = oss.r('qdbus org.kde.konsole /Sessions/%s sendText "%s"' % (session, cmd), '|') if s.strip(): print s.rstrip() s = oss.r('~/bin/qdsendnl %s' % session, '|') if s.strip(): print s.rstrip()
def main(argv): #------------------------------------------------------------------------------- """ usage: mcp [options] copies files that have changed in monotone options: -d | --disp : display only (no copy) -f | --force : force copy of everything -u | --update : update from monotone """ args, opts = oss.gopt(oss.argv[1:], [('d', 'disp'), ('f', 'force'), ('u', 'update')], [], None) db = McpDb(opts.disp) if opts.update: args = [] v = oss.r('mtn status', '|') for line in v[:-1].split('\n'): if line.startswith(' patched') or line.startswith(' added'): d, fl = line.split() args.append(fl) if opts.force is None: args = db.whatChanged(args) else: args = db.checkAll() for a in args: if opts.disp is None: print "pscp -pw kibsop) %s [email protected]:work/sdc.hpl.hp.com/eucalyptus/%s" % ( a, a) oss.r( "pscp -pw kibsop) %s [email protected]:work/sdc.hpl.hp.com/eucalyptus/%s" % (a, a)) else: print a oss.exit(0)
def run(self, fn, force=False): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - oss.r('indent1.exe ' + self.indentOptions + ' ' + fn) return bfn = self.makeBU(fn, force) inf = open(bfn, 'rU') otf = open(fn, 'w') ol2 = ol1 = ls = None for line in inf: ol2 = ol1 ol1 = ls ls = line.strip() if not ls: otf.write('\n') continue if ls.startswith('if') or ls.startswith('for') or ls.startswith('while') or ls.startswith('switch'): if ol1: otf.write('\n') otf.write(line) elif ls.endswith('('): if line[0] not in [' '] or (len(ls.split()) > 1 and '=' not in line): if ol2: otf.write('\n') if ol1: otf.write('\n') otf.write('//' + ('-'*78) +'\n') otf.write(line) otf.write('//' + ('-'*78) +'\n') elif ls.startswith('break'): otf.write(line) otf.write('\n') else: otf.write(line)
def main(argv): #------------------------------------------------------------------------------- """ usage: cfd.py [options] <file_name> [<filename> ...] options: -n | --nocheck : do not check for CVS root displays diffs for files versus top of truck for either a CVS or monotone archive """ args, opts = oss.gopt(argv[1:], [('n', 'nocheck')], [], main.__doc__) if oss.exists('CVS'): if opts.nocheck is None: CvsRootCheck() cmd = r"C:\bin\cvs.exe diff %s" else: cmd = "mtn diff --context %s" for arg in args: oss.r(cmd % arg) oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- """ usage: mkcvs [OPTIONS] <dir> Makes a cvs archive from the specified directory Options: -i | --ignore : specify extensions or files or directories to ignore example: -i .bmp -i .jpg or -i badfile """ args, opts = oss.gopt(argv[1:], [], [], [], [('i', 'ignore')], main.__doc__) if not oss.exists(oss.env['CVSROOT']): print "CVSROOT is down" oss.exit(1) if args: oss.cd(args[0]) name = oss.basename(oss.pwd()) if oss.exists(oss.env['CVSROOT'] + '/' + name): print >> oss.stderr, "Already exists:", oss.env['CVSROOT'] + '/' + name oss.exit(1) if opts.ignore is not None: if isinstance(opts.ignore, list): IGNORE_PATTERNS.extend(opts.ignore) else: IGNORE_PATTERNS.append(opts.ignore) il = bldIgnoreList() print "Ignoring Files: '%s'" % il oss.r(r'C:\bin\cvs.exe import %s %s %s %s1' % (il, name, name, name)) oss.cd('..') oss.r("mv %s /tmp/%s.bak" % (name, name)) oss.r(r'C:\bin\cvs.exe co %s' % name) oss.cd(name) for f in oss.ls(): print f oss.r("C:\bin\cf.py") oss.exit(0)
def create(self, args, opts): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if not self.cvsup: print('CVS Archive "%s" is down' % self.root, file=oss.stderr) return name = args[0] if args else oss.basename(oss.pwd()) if not self.root.startswith(':pserver:'): if oss.exists(self.root + '/' + name): if opts.force: pass else: print('CVS Archive "%s" exists' % name, file=oss.stderr) return msg = opts.msg if opts is not None else 'Initial Checkin: ' + name questionable = set([ '*' + ext for ext in self.QuestionableExtensions]) binaries = set([ '*' + ext for ext in self.BinExts]) il = "-I! " + ' '.join([ '-I "%s"' % pat for pat in (self.IgnorePatterns | questionable | binaries)]) oss.r(self.exe + ' import -m"%s" %s %s %s %s1' % (msg, il, name, name, name)) self.co(None, opts)
def main(argv): #------------------------------------------------------------------------------- """ usage: """ args, opts = oss.gopt(argv[1:], [('p', 'pause')], [], __doc__ + main.__doc__) install_dir = oss.env['MYEDIT_DIRECTORY'] print('MyEdit installed at: "%s"' % install_dir) print('\nUpdating "myedit"') oss.cd(install_dir) t = oss.r('cvs.exe up -d', '|') printResults(t) print('\nUpdating "pylib"') oss.cd('C:/bin/pylib/pylib') t = oss.r('cvs.exe up -d', '|') printResults(t) print('\nIf MyEdit is running, it must be restarted.') if opts.pause: raw_input('\n<Hit key to continue>') oss.exit(0)
def main(argv): #------------------------------------------------------------------------------- """ usage: mk_cmd_help.py [options] [<file_name> ...] options: -o | --output : html file output <default: 'cmd_help.html' generate an html output file of the help strings from the specified commands """ args, opts = oss.gopt(argv[1:], [], [('o', 'output')], main.__doc__ + __doc__) outfile = 'cmd_help.html' if opts.output is None else opts.output if len(args) == 0: args = oss.ls('*.py') title = oss.pwd() print("Writing to file: '%s'" % outfile) with open(outfile, 'w') as otf: otf.write(HTML_BEGIN % (title, title)) ## make a table of links to prgms details links = ['<a href="#{0}">{0}</a>'.format(nm) for nm in args] otf.write('<a name="top"><h2>Contents</h2></a>\n') otf.write("<center>\n" + utils.makeTable(links, tattr='border="1" width="90%"') + "\n</center>\n\n") otf.flush() ## make an entry for each prgms details for prgm in args: print(prgm) otf.write('\n\n<hr/>\n') otf.write('<a name="{0}">'.format(prgm)) otf.write('<h2>' + prgm + '</h2></a>\n') s = oss.r(prgm + ' --help', '$') otf.write('<font size="5"><pre>' + cgi.escape(s) + '</pre></font>\n') otf.write('<a href="#top">Top</a>\n') otf.flush() otf.write(HTML_END) oss.exit(0)
def compile(javac, srcList, force=False, readOnly=False, stopFirst=True): #------------------------------------------------------------------------------- rc = 0 for sc in srcList: pth, fn = sc.rsplit('\\', 1) pth1 = pth.split('\\', 2)[2] cdir = BUILD_PATH + '/' + pth1 oss.mkdirs(cdir) fd = fn.rsplit('.', 1)[0] nf = cdir + '/' + fd + '.class' if force or not oss.exists(nf) or oss.newerthan(sc, nf): cmd = javac + " -cp %s -d %s %s" % (CLASS_PATH, BUILD_PATH, sc) print(cmd) if not readOnly: rc = oss.r(cmd) if rc and stopFirst: oss.exit(rc) return rc
def main(argv): #------------------------------------------------------------------------------ args, opts = oss.gopt(argv[1:], [], [], "") if not args: args = machs.keys() for m in args: if m not in machs: print "unknown machine", m continue print "Opening", m session = oss.r("qdbus org.kde.konsole /Konsole newSession", '$').strip() s = oss.r( "qdbus org.kde.konsole /Sessions/%s setTitle 1 %s" % (session, m), '|') if s.strip(): print s.rstrip() s = oss.r( 'qdbus org.kde.konsole /Sessions/%s sendText "ssh %s"' % (session, m), '|') if s.strip(): print s.rstrip() s = oss.r('~/bin/qdsendnl %s' % session, '|') if s.strip(): print s.rstrip() for cmd in machs[m]: if cmd: s = oss.r( 'qdbus org.kde.konsole /Sessions/%s sendText "%s"' % (session, cmd), '|') if s.strip(): print s.rstrip() s = oss.r('~/bin/qdsendnl %s' % session, '|') if s.strip(): print s.rstrip()
def main(argv): #------------------------------------------------------------------------------- """ usage: """ args, opts = oss.gopt(argv[1:], [('f', 'force'), ('r', 'readonly'), ('m', 'makecmd')], [('c', 'cmdfile')], main.__doc__ + __doc__) global BUILD_PATH, CLASS_PATH if opts.cmdfile: if opts.makecmd and not oss.exists(opts.cmdfile): oss.touch(opts.cmdfile) with open(opts.cmdfile) as inf: dd = yaml.load(inf.read()) if dd is None: dd = {} slist = dd['files'] if 'files' in dd else [] BUILD_PATH = dd['build_path'] if 'build_path' in dd else './class' CLASS_PATH = dd['class_path'] if 'class_path' in dd else BUILD_PATH if not slist: slist = oss.find('.', "*.java") if 'cmds' in dd: CMDS = dd['cmds'] else: CMDS = ['compile'] if opts.makecmd: oss.mv(opts.cmdfile, opts.cmdfile + '.bak') with open(opts.cmdfile, 'w') as otf: slist.extend(oss.find('.', "*.java")) ## ensure names are unique s = set(slist) slist = [a for a in s] dd['files'] = slist otf.write(yaml.safe_dump(dd)) else: CMDS = ['compile'] slist = oss.find('.', "*.java") if args: CMDS = args rc = 0 for cmd in CMDS: if rc != 0: oss.exit(rc) if cmd == 'compile': rc = compile(JAVAC, slist, opts.force, opts.readonly) elif cmd.startswith('run '): c = cmd[4:].strip() print(c) rc = oss.r(c) elif cmd == 'vcs_add': addToVcs(VCS_ADD, slist) oss.exit(0)
def addToVcs(vcsAdd, srcList): #------------------------------------------------------------------------------- for f in srcList: cmd = vcsAdd + ' ' + str(f) print(cmd) oss.r(cmd)
def run(self): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - oss.r(self.cmd)
def run(mach, cmd, user="", passwd="", timeout=30): #------------------------------------------------------------------------------- if user: user += "@" print "here1" oss.r(SSH + " %s%s %s" % (user, mach, cmd))
def _read_input(self, completionListFunc, prompt): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - self.pl = len(prompt) self.write(prompt) self.historyIdx = 0 while 1: self.update() ch = self.screen.readKey() key = ch.VirtualKeyCode actions = [KEY_MAP[key]] if key in KEY_MAP else WordStarKeyMapping( key, self.screen.readKey) if not actions: actions = self.vi.getKey(key) if not actions: actions = ['KEY'] for action in actions: ## return key if action == 'RET': cmdstr = self.getCmdStr() self.setNewLine() if cmdstr.endswith(self.continuationChar): del self.cmd[-1] return self._read_input(completionListFunc, self.promptContinue) self.addHistory(cmdstr) return cmdstr ## backspace elif action == 'BKSP': if self.x != self.pl: #print "\n", self.x, self.pl, "\n" try: del self.cmd[self.x - self.pl - 1] except IndexError: pass self.setCursor(self.x - 1) ## up arrow elif action == 'UP': cmd = self.getHistory() self.historyIdx += 1 self.setCmdStr(cmd, self.pl + len(cmd)) ## down arrow elif action == 'DOWN': self.historyIdx -= 1 cmd = self.getHistory() self.setCmdStr(cmd, self.pl + len(cmd)) ## left arrow elif action == 'LEFT': self.setCursor(self.x - 1) ## right arrow elif action == 'RGHT': self.setCursor(self.x + 1) ## home elif action == 'HOME': self.setCursor(self.pl) ## end elif action == 'END': self.setCursor(self.pl + len(self.cmd)) ## tab (auto completion) elif action == 'TAB': ## returns either: ## - none for no matches ## - a str which is the new cmd string ## - a list of choices res = completionListFunc(self, self.getCmdStr()) if res is not None: if isinstance(res, (str, unicode)): self.setCmdStr(res, self.pl + len(res)) else: x = self.x self.setNewLine() self.write(' '.join(res)) self.setNewLine() self.write(self.prompt) self.update() self.setCursor(x) elif action == 'RM_EOL': self.cmd = self.cmd[:(self.x - self.pl)] elif action == 'DEL_CHAR': try: del self.cmd[self.x - self.pl] except IndexError: pass elif action == 'EDITOR': otf = open('/tmp/mysh.txt', 'w') otf.write(self.getCmdStr()) otf.close() oss.r('vi /tmp/mysh.txt') inf = open('/tmp/mysh.txt') cmdstr = ' '.join([line[:-1] for line in inf.readlines()]) self.clear() self.write(prompt) self.setCmdStr(cmdstr, self.pl) elif action == 'NOP': pass ## other key else: self.addChar(ch.Char) self.setCursor(self.x + 1)
def RmtCmd2Str(self, cmd, chdir=False): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - return oss.r(self.mkRmtCmd(cmd, chdir), '|').strip()
def Save(self, buf, fullSave=True): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - LocalFileObject.Save(self, buf) if fullSave: print("pscp " + self.FileName + " " + self.rmtfile) oss.r("pscp " + self.FileName + " " + self.rmtfile)
def main(argv): #------------------------------------------------------------------------------- """ runit.py [-p] [-b] [-m] [-k] [-x] [-d <PathDir>] <script> -p | --pause : pause after completion -b | --build : generate build style output -m | --nomain : disable calling main -k | --nomake : disable running make -x | --nodebug : disable debug flag -a | --absdir : absolute path given, don't use for wkdir -d | --wkdir <PathDir> : directory where program is <script>: script to run or 'build' runit supports execution of python scripts from within Slickedit. Since a window is created on execution (and is destroyed upon completion), console programs need to block on user input to allow execution results to be seen. -p does this. Also, exceptions often cause the blocking code to be bypassed, such that errors cannot be seen at all. Even when visible, the default dump format is not easily parsed by editors. -b does this. Many forms of errors can be detected by 'importing' the program without running the main code. -m does this. -d or providing the full path in the script names allows local directory modules to be found as if the script was run directly from the local directory. Version 1.0 """ args, opt = oss.gopt(argv[1:], [('p', 'pause'), ('b', 'build'), ('m', 'nomain'), ('k', 'nomake'), ('x', 'nodebug'), ('a', 'absdir')], [('d', 'wkdir')], main.__doc__) oss.echo("die", "/tmp/runit_die") time.sleep(2) oss.rm("/tmp/runit_die") if not args: opt.usage(1, "Must supply a program to run") prgmName = oss.path(args[0]) if opt.wkdir is None: pdir = prgmName.drive_path opt.wkdir = pdir if pdir and opt.absdir else '.' if 0: thread.start_new_thread(look_out, (1, )) global moduleName, fileName, globd moduleName = prgmName.name fileName = prgmName.drive_path_name + '.py' globd = {} exec('import sys', globd) ## enable local modules to be found wd = oss.abspath(opt.wkdir) globd['sys'].path.insert(0, wd) ## if calling main is disabled, use build semantics if opt.nomain: opt.build = True try: ## recreate argv globd['sys'].argv = [fileName] + args[1:] ## if calling main is disabled, change name globd["__name__"] = "__main__" if opt.nomain is None else moduleName if opt.nodebug is not None: globd["__debug__"] = True if opt.build is None: print("CmdLine: '%s'" % " ".join(globd['sys'].argv)) ## run a makefile if it exists if opt.nomake is None: if oss.exists("make.pmk") or oss.exists("nmake.pmk"): oss.r('python C:\\bin\\pmake.py') elif oss.exists("makefile"): oss.r('make') sys.path = globd['sys'].path sys.argv = globd['sys'].argv reload(oss) sys.modules['runit'] = sys.modules['__main__'] try: sys.modules['__main__'] = __import__(moduleName) except ImportError: print(sys.path, file=oss.stderr) try: execfile(sys.modules['runit'].fileName, sys.modules['runit'].globd) except SystemExit: pass if opt.pause and not opt.build: print("-- continue --") sys.stdin.readline() except Exception: if opt.build: ## print error message(s) in form many editors can parse t, v, tb = sys.exc_info() traceback.print_exc() print(traceback.extract_tb(tb)) tbl = traceback.extract_tb(tb)[-1] s = traceback.format_exception_only(t, v) err = "".join(s) if s[0].find('File') != -1: l = s[0].split() print("%s(%s):\n" % (l[1].split('"')[1], l[3]), err) else: print("%s(%d):\n" % (tbl[0], tbl[1]), err) else: ## standard dump semantics traceback.print_exc() print("-- continue --") sys.stdin.readline()
def timeOneRun(cmd): #------------------------------------------------------------------------------- st = time.time() oss.r(cmd) et = time.time() return et - st
def cpf(mach, srcFiles, dest, options="", user="", passwd="", timeout=300): #------------------------------------------------------------------------------- if user: user += "@" oss.r(SCP + " %s %s%s:%s %s" % (options, user, mach, srcFiles, dest))
def Load(self): #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - print("pscp " + self.rmtfile + " " + self.FileName) oss.r("pscp " + self.rmtfile + " " + self.FileName) return LocalFileObject.Load(self)