def __init__(self, command_line, lock, debug, interactive = False):
self.yesno = False
self.last_exception = None
self.trans = None
tuple = self.__init_alpm__(debug)
if tuple == None:
sys.exit(1)
(self.alpm, self.pmc_syncs, self.config) = tuple
self.__alpm_open_dbs__()
self.lock = lock
self.th_ended_event = threading.Event()
self.th_ended_event.clear()
self.timer = threading.Timer(1.0, self.handle_timer)
self.uid = posix.getuid()
# pid of pacman process
self.pid = 0
# catch SIGINT and call the handler
#signal.signal(signal.SIGINT, self.sigint)
self.PS1 = "#"
self.greet = "Welcome to guzuta!\n"
self.prompt = self.PS1 + " "
self.prev_return = None
self.REASON_EXPLICIT = 0
def create_pisi_kga(parent,name):
global kapp
global nonPrivMode
nonPrivMode = posix.getuid()
kapp = KApplication.kApplication()
return MainApplication(parent, name)
def __init__(self, mandir, manpages, manoptions=None, vimoptions=None):
'''
Arguments:
mandir (str) -- Directory to store temporary man pages
manpages (list) -- Manuals to display
'''
# Grab the list of man pages passed to vman() and set it to a class
# variable.
self.manpages = manpages
# Set up the main directory to use
self.d = '{}/{}'.format(mandir, posix.getuid())
# Command bits. Allows changing the man command or vim command and
# their arguments.
self.man = 'man'
self.vim = 'vim'
self.manfnd = [self.man, '-w']
if manoptions:
self.manfnd.extend(manoptions)
self.catcmd = [self.man, '--encoding=UTF-8', '--pager=cat']
# Sets some basic vim options:
# - nonumber: removes numbering regardless of the setting in vimrc
# - laststatus=2: always show the status bar information
# - hidden: allow switching buffers without closing them
# - ft=man: make vim use the man-style highlighting
self.vimcmd = [self.vim, '-n', '-f', '-M']
if vimoptions:
self.vimcmd.extend(vimoptions)
else:
self.vimcmd.extend(
['-c', 'set nonumber laststatus=2 hidden ft=man'])
def main():
global kapp
global nonPrivMode
global packageToInstall
about_data = AboutData()
KCmdLineArgs.init(sys.argv,about_data)
KCmdLineArgs.addCmdLineOptions ([("install <package>", I18N_NOOP("Package to install"))])
if not KUniqueApplication.start():
print i18n("Pisi KGA is already running!")
return
nonPrivMode = posix.getuid()
kapp = KUniqueApplication(True, True, True)
args = KCmdLineArgs.parsedArgs()
if args.isSet("install"):
packageToInstall = str(KIO.NetAccess.mostLocalURL(KURL(args.getOption("install")), None).path())
else:
packageToInstall = None
myapp = MainApplication()
kapp.setMainWidget(myapp)
sys.exit(myapp.exec_loop())
class PosixGroupsTester(unittest.TestCase):
if posix.getuid() == 0 and hasattr(posix, 'getgroups') and sys.platform != 'darwin':
def setUp(self):
self.saved_groups = posix.getgroups()
def tearDown(self):
if hasattr(posix, 'setgroups'):
posix.setgroups(self.saved_groups)
elif hasattr(posix, 'initgroups'):
name = pwd.getpwuid(posix.getuid()).pw_name
posix.initgroups(name, self.saved_groups[0])
if hasattr(posix, 'initgroups'):
def test_initgroups(self):
# find missing group
groups = sorted(self.saved_groups)
for g1,g2 in zip(groups[:-1], groups[1:]):
g = g1 + 1
if g < g2:
break
else:
g = g2 + 1
name = pwd.getpwuid(posix.getuid()).pw_name
posix.initgroups(name, g)
self.assertIn(g, posix.getgroups())
if hasattr(posix, 'setgroups'):
def test_setgroups(self):
for groups in [[0], range(16)]:
posix.setgroups(groups)
self.assertListEqual(groups, posix.getgroups())
def __init__(self, collab=None, user=None, backend=backend):
farmconf = backend.config.get("collab", "farmconf")
self.farmconfdir = os.path.dirname(farmconf)
self.request = None
if collab:
self.confdir = os.path.join(backend.wikidir, collab, "config")
else:
baseinstancedir = backend.config.get("collab", "baseinstancedir")
self.confdir = os.path.join(baseinstancedir, "config")
if not os.path.isdir(self.confdir):
raise OSError(errno.ENOENT, "No such directory: " + self.confdir)
if user:
self.user = user
else:
self.user = pwd.getpwuid(posix.getuid())[0]
sys.path.insert(0, self.confdir)
multiconfig._url_re_cache = None
multiconfig._farmconfig_mtime = None
multiconfig._config_cache = {}
import farmconfig
reload(farmconfig)
self.request = RequestCLI("FrontPage", parse=False)
self.request.user = self.getUser(self.user)
def _InitDefaults(self):
# Default value; user may unset it.
# $ echo -n "$IFS" | python -c 'import sys;print repr(sys.stdin.read())'
# ' \t\n'
SetGlobalString(self, 'IFS', split.DEFAULT_IFS)
SetGlobalString(self, 'PWD', posix.getcwd())
# NOTE: Should we put these in a namespace for Oil?
SetGlobalString(self, 'UID', str(posix.getuid()))
SetGlobalString(self, 'EUID', str(posix.geteuid()))
SetGlobalString(self, 'HOSTNAME', str(libc.gethostname()))
# In bash, this looks like 'linux-gnu', 'linux-musl', etc. Scripts test
# for 'darwin' and 'freebsd' too. They generally don't like at 'gnu' or
# 'musl'. We don't have that info, so just make it 'linux'.
SetGlobalString(self, 'OSTYPE', str(posix.uname()[0].lower()))
# For getopts builtin
SetGlobalString(self, 'OPTIND', '1')
# For xtrace
SetGlobalString(self, 'PS4', '+ ')
# bash-completion uses this. Value copied from bash. It doesn't integrate
# with 'readline' yet.
SetGlobalString(self, 'COMP_WORDBREAKS', util.READLINE_DELIMS)
def getFullname(self):
if os.environ.has_key('SQUISH_NAME'):
return os.environ['SQUISH_NAME']
else:
uid = posix.getuid()
return pwd.getpwuid(uid)[4] # fifth field is fullname
return None
def __init__(self, outputDirectory, package): self.outputDirectory = outputDirectory self.package = package self.date = now() self.user = getpwuid(getuid())[0] self.DO_NOT_PROCESS = DO_NOT_PROCESS self.BACK_REFERENCE_OVERRIDE = BACK_REFERENCE_OVERRIDE self.BACK_REFERENCE_LINK_OVERRIDE = BACK_REFERENCE_LINK_OVERRIDE
def got_mx(result):
mx_list = result[0]
mx_list.sort(lambda x, y: cmp(x.payload.preference, y.payload.preference))
if len(mx_list) > 0:
import posix, pwd
import socket
from twisted.internet import reactor
reactor.connectTCP(str(mx_list[0].payload.name), 25,
SMTPClientFactory('@'.join((pwd.getpwuid(posix.getuid())[0],socket.gethostname())), EMAIL_RECIPIENT, 'xml-files', file))
def get_xauthority():
xauth = os.getenv("XAUTHORITY")
if not xauth:
home = os.getenv("HOME")
if not home:
import posix, pwd
home = pwd.getpwuid(posix.getuid())[5]
xauth = home + "/.Xauthority"
return xauth
def create_pisi_kga(parent,name):
global kapp
global nonPrivMode
global packageToInstall
packageToInstall = None
nonPrivMode = posix.getuid()
kapp = KApplication.kApplication()
return MainApplication(parent, name)
def get_xauthority():
xauth = os.getenv("XAUTHORITY")
if not xauth:
home = os.getenv("HOME")
if not home:
import posix, pwd
home = pwd.getpwuid(posix.getuid())[5]
xauth = home + "/.Xauthority"
return xauth
def got_mx(result):
mx_list = result[0]
mx_list.sort(lambda x, y: cmp(x.payload.preference, y.payload.preference))
if len(mx_list) > 0:
import posix
import pwd
import socket
reactor.connectTCP(str(mx_list[0].payload.name), 25,
SMTPClientFactory('@'.join((pwd.getpwuid(posix.getuid())[0], socket.gethostname())), '*****@*****.**', 'xml-files', os.path.join('/tmp', args[0] + '.tgz')))
def getUsername(self):
if os.environ.has_key('SQUISH_USER'):
return os.environ['SQUISH_USER']
elif os.environ.has_key('USER'):
return os.environ['USER']
else:
uid = posix.getuid()
return pwd.getpwuid(uid)[0] # first field is username
return None
def run():
usage = "usage: %prog [options] <path to wiki> <pagename>"
parser = OptionParser(usage=usage)
parser.add_option("-v",
"--verbose",
action="store_true",
dest="verbose",
help="Report success")
parser.add_option("-a",
"--auth",
action="store_true",
dest="auth",
help="Use local user-based wiki authentication")
parser.add_option("-c",
"--comment",
dest="comment",
help="Optional change comment for the edit")
(options, args) = parser.parse_args()
if len(args) != 2:
print parser.get_usage()
sys.exit(2)
# Configdir to path, so wikiconfig can be imported by Request
cp = args[0]
cp2 = os.path.join(cp, 'config')
if os.path.isdir(cp2):
cp = cp2
sys.path.insert(0, cp)
pagename = unicode(args[1], sys.getfilesystemencoding())
# Make a new request for the page
req = MinimalMoinScript(pagename, parse=False)
req.page = Page(req, pagename)
# Auth
if options.auth:
import posix, pwd
# We need to import contexts before importing users, because otherwise
# the relative imports in MoinMoin will fail.
import MoinMoin.web.contexts
from MoinMoin.user import User
req.user = User(req, auth_username=pwd.getpwuid(posix.getuid())[0])
mytext = unicode(sys.stdin.read(), sys.getfilesystemencoding())
if options.comment:
savetext(req, pagename, mytext, comment=unicode(options.comment))
else:
savetext(req, pagename, mytext)
# Must finish the request to ensure that metadata is saved
graphdata_close(req)
def get_emailadress():
emailadress = ''
user = getpwuid(getuid())[0]
arg = 'ldapsearch -x uid={0}'.format(user).split(' ')
# in case ldap is not installed on the system, email will be left blank
try:
result = Popen(arg, stdout=PIPE)
result = result.communicate()[0].split('\n')
emailadress = [i for i in result if i.startswith('mail:')][0][6:]
except OSError:
pass
return emailadress
def test_initgroups(self):
# find missing group
groups = sorted(self.saved_groups)
for g1,g2 in zip(groups[:-1], groups[1:]):
g = g1 + 1
if g < g2:
break
else:
g = g2 + 1
name = pwd.getpwuid(posix.getuid()).pw_name
posix.initgroups(name, g)
self.assertIn(g, posix.getgroups())
def GetHomeDir():
"""Get the user's home directory from the /etc/passwd.
Used by tilde expansion in word_eval.py and readline initialization in
completion.py.
"""
uid = posix.getuid()
try:
e = pwd.getpwuid(uid)
except KeyError:
return None
else:
return e.pw_dir
def test_initgroups(self):
# find missing group
groups = sorted(self.saved_groups)
for g1, g2 in zip(groups[:-1], groups[1:]):
g = g1 + 1
if g < g2:
break
else:
g = g2 + 1
name = pwd.getpwuid(posix.getuid()).pw_name
posix.initgroups(name, g)
self.assertIn(g, posix.getgroups())
def GetHomeDir():
"""Get the user's home directory from the /etc/passwd.
Used by $HOME initialization in osh/state.py. Tilde expansion and readline
initialization use mem.GetVar('HOME').
"""
uid = posix.getuid()
try:
e = pwd.getpwuid(uid)
except KeyError:
return None
else:
return e.pw_dir
def got_mx(result):
mx_list = result[0]
mx_list.sort(lambda x, y: cmp(x.payload.preference, y.payload.
preference))
if len(mx_list) > 0:
import posix, pwd
import socket
reactor.connectTCP(
str(mx_list[0].payload.name), 25,
SMTPClientFactory(
'@'.join((pwd.getpwuid(posix.getuid())[0],
socket.gethostname())),
'*****@*****.**', 'xml-files',
os.path.join('/tmp', args[0] + '.tgz')))
def got_mx(result):
mx_list = result[0]
mx_list.sort(lambda x, y: cmp(x.payload.preference,
y.payload.preference))
if len(mx_list) > 0:
import posix
import pwd
import socket
from twisted.internet import reactor
sender = (pwd.getpwuid(posix.getuid())[0] +
'@' + socket.gethostname())
reactor.connectTCP(str(mx_list[0].payload.name), 25,
SMTPClientFactory(sender, EMAIL_RECIPIENT,
'xml-files', file))
def remove_nodeps(self, what = ''):
uid = posix.getuid()
if uid != 0:
print "You are not ROOT. Bye bye."
return
if what == '':
print 'Please specify a package to remove'
return
self.run_pacman_with('-Rd ' + what)
out = self.__capture_output__()
(pid, self.exit_status) = os.wait()
if self.exit_status != 0:
return False
return True
def which(s):
for i in os.getenv('PATH').split(':'):
x = os.path.normpath(os.path.join(i, s))
try:
st = os.stat(x)
except:
continue
if not stat.S_ISREG(st[stat.ST_MODE]):
continue
r = stat.S_IMODE(st[stat.ST_MODE])
uid = st[stat.ST_UID]
gid = st[stat.ST_GID]
if (r & 0001) or (gid in posix.getgroups() and r & 0010) \
or (uid == posix.getuid() and r & 0100):
return x
def main():
global kapp
global nonPrivMode
about_data = AboutData()
KCmdLineArgs.init(sys.argv,about_data)
if not KUniqueApplication.start():
print i18n("Pisi KGA is already running!")
return
nonPrivMode = posix.getuid()
kapp = KUniqueApplication(True, True, True)
myapp = MainApplication()
kapp.setMainWidget(myapp)
sys.exit(myapp.exec_loop())
def run():
usage = "usage: %prog [options] <path to wiki> <pagename>"
parser = OptionParser(usage=usage)
parser.add_option("-v", "--verbose", action="store_true", dest="verbose",
help="Report success")
parser.add_option("-a", "--auth", action="store_true", dest="auth",
help="Use local user-based wiki authentication")
parser.add_option("-c", "--comment", dest="comment",
help="Optional change comment for the edit")
(options, args) = parser.parse_args()
if len(args) != 2:
print parser.get_usage()
sys.exit(2)
# Configdir to path, so wikiconfig can be imported by Request
cp = args[0]
cp2 = os.path.join(cp, 'config')
if os.path.isdir(cp2):
cp = cp2
sys.path.insert(0, cp)
pagename = unicode(args[1], sys.getfilesystemencoding())
# Make a new request for the page
req = MinimalMoinScript(pagename, parse=False)
req.page = Page(req, pagename)
# Auth
if options.auth:
import posix, pwd
# We need to import contexts before importing users, because otherwise
# the relative imports in MoinMoin will fail.
import MoinMoin.web.contexts
from MoinMoin.user import User
req.user = User(req, auth_username=pwd.getpwuid(posix.getuid())[0])
mytext = unicode(sys.stdin.read(), sys.getfilesystemencoding())
if options.comment:
savetext(req, pagename, mytext, comment=unicode(options.comment))
else:
savetext(req, pagename, mytext)
# Must finish the request to ensure that metadata is saved
graphdata_close(req)
def download(self, what = ''):
uid = posix.getuid()
self.prev_return = None
if uid != 0:
print "You are not ROOT. Bye bye."
return
if what == '':
print 'Please specify a package to remove'
return
print 'running <%s>' % ('-Sw ' + what)
self.run_pacman_with('-Sw ' + what)
#out = self.__capture_output__()
(pid, self.exit_status) = os.wait()
self.prev_return = (self.exit_status, out)
return
def get_pkg_files(self, what = ''):
uid = posix.getuid()
self.prev_return = None
#if uid != 0:
# print "You are not ROOT. Bye bye."
# return
if what == '':
print 'Please specify a package to remove'
return
self.run_pacman_with('-Ql ' + what)
out = self.__capture_output__()
(pid, self.exit_status) = os.wait()
self.prev_return = (self.exit_status, out)
return
def _InitDefaults(self):
# Default value; user may unset it.
# $ echo -n "$IFS" | python -c 'import sys;print repr(sys.stdin.read())'
# ' \t\n'
SetGlobalString(self, 'IFS', split.DEFAULT_IFS)
SetGlobalString(self, 'PWD', posix.getcwd())
# NOTE: Should we put these in a namespace for Oil?
SetGlobalString(self, 'UID', str(posix.getuid()))
SetGlobalString(self, 'EUID', str(posix.geteuid()))
# For getopts builtin
SetGlobalString(self, 'OPTIND', '1')
# For xtrace
SetGlobalString(self, 'PS4', '+ ')
# bash-completion uses this. Value copied from bash. It doesn't integrate
# with 'readline' yet.
SetGlobalString(self, 'COMP_WORDBREAKS', util.READLINE_DELIMS)
def main(argv):
if len(argv) != 4:
print "Usage: %s <wiki> <report name> <parameters in json format>" % argv[0]
print "e.g. %s nlwiki newpagevswikidata []" % argv[0]
raise SystemExit()
import pwd, posix
homedir = pwd.getpwuid(posix.getuid())[5]
cfgfile = homedir + "/.reports.cfg"
cfg = dict()
execfile(cfgfile, cfg)
cfg['homedir'] = homedir
from Reports import ReportContext
rc = ReportContext(cfg)
report = rc.reports[argv[2]]
import json
logging_update_report(argv[1], report, json.loads(argv[3]))
def main(argv):
if len(argv) != 4:
print "Usage: %s <wiki> <report name> <parameters in json format>" % argv[
0]
print "e.g. %s nlwiki newpagevswikidata []" % argv[0]
raise SystemExit()
import pwd, posix
homedir = pwd.getpwuid(posix.getuid())[5]
cfgfile = homedir + "/.reports.cfg"
cfg = dict()
execfile(cfgfile, cfg)
cfg['homedir'] = homedir
from Reports import ReportContext
rc = ReportContext(cfg)
report = rc.reports[argv[2]]
import json
logging_update_report(argv[1], report, json.loads(argv[3]))
def parseCommandLine(argv):
gopts.reset()
args = gopts.parse(argv)
if gopts.vals.help:
gopts.usage()
if gopts.vals.help or gopts.vals.help_config:
gopts.load_defconfig(help=1)
if gopts.vals.help or gopts.vals.help_config:
return (None, None)
if not gopts.vals.display:
gopts.vals.display = os.getenv("DISPLAY")
if not gopts.vals.xauthority:
xauth = os.getenv("XAUTHORITY")
if not xauth:
home = os.getenv("HOME")
if not home:
import posix, pwd
home = pwd.getpwuid(posix.getuid())[5]
xauth = home + "/.Xauthority"
gopts.vals.xauthority = xauth
# Process remaining args as config variables.
for arg in args:
if '=' in arg:
(var, val) = arg.strip().split('=', 1)
gopts.setvar(var.strip(), val.strip())
if gopts.vals.config:
config = gopts.vals.config
else:
gopts.load_defconfig()
preprocess(gopts.vals)
if not gopts.getopt('name') and gopts.getopt('defconfig'):
gopts.setopt('name', os.path.basename(gopts.getopt('defconfig')))
config = make_config(gopts.vals)
return (gopts, config)
def remove(self, what = ''):
uid = posix.getuid()
self.prev_return = None
if uid != 0:
print "You are not ROOT. Bye bye."
return
if what == '':
print 'Please specify a package to remove'
return
self.run_pacman_with('-R ' + what)
out = self.__capture_output__()
(pid, self.exit_status) = os.wait()
dependencies = []
if self.exit_status != 0:
pattern = '\n'
tmp = re.split(pattern, out)
for string in tmp:
if string != '':
dependencies.append(string[string.rfind(' ')+1:])
#return (self.exit_status, dependencies, out)
self.prev_return = (self.exit_status, dependencies, out)
return
def rootUserCheck(self):
if posix.getuid() != 0 and self.config.rootUserCheck():
raise RuntimeError("User root needed to execute database init")
def tearDown(self):
if hasattr(posix, 'setgroups'):
posix.setgroups(self.saved_groups)
elif hasattr(posix, 'initgroups'):
name = pwd.getpwuid(posix.getuid()).pw_name
posix.initgroups(name, self.saved_groups[0])
def myself():
return User(pwd.getpwuid(posix.getuid())[0])
def get_homedir():
import pwd, posix
homedir = pwd.getpwuid(posix.getuid())[5]
return homedir
def ldap_myself():
'''Returns the LDAP DN of the current user'''
return ldap_byuid(posix.getuid())
def tearDown(self):
if hasattr(posix, 'setgroups'):
posix.setgroups(self.saved_groups)
elif hasattr(posix, 'initgroups'):
name = pwd.getpwuid(posix.getuid()).pw_name
posix.initgroups(name, self.saved_groups[0])
def Method1():
global code
user_id = getUserID(input('# Type your user login ID : '))
for entry in posix.listdir('/proc/'):
if entry.isnumeric() == True:
if posix.stat('/proc/' + entry).st_uid == user_id:
code = 'Continue'
break
if code == 'Continue':
print('# Any process belonged to typed user is found.')
while True:
option = input(
'# Do you want to send signal to these processes for closing? (Y/N) : '
)
if option in ['Y', 'N']:
break
if option == 'N':
code = 'Cancelled'
return
else:
print('# Retriving processes list...')
pids = []
for entry in posix.listdir('/proc/'):
if entry.isnumeric() == True:
if posix.stat('/proc/' + entry).st_uid == user_id:
pids.append(int(entry))
print('# Quitting processes...')
if posix.getuid() != user_id and posix.getuid() != 0:
print(
'# Error : Don\'t have enough permission. Make sure to run this troubleshooter as root.'
)
code = 'RequiredRoot'
return
for pid in pids:
posix.kill(pid, 15)
input(
'Waiting for processes to be closed properly (Recommended at 20 seconds). When ready then press enter.'
)
print('# Retriving processes list...')
pids = []
for entry in posix.listdir('/proc/'):
if entry.isnumeric() == True:
if posix.stat('/proc/' + entry).st_uid == user_id:
pids.append(int(entry))
if pids:
while True:
option = input(
'# There are processes not quitted by the signal. Do you want to force killing it? (Y/N) : '
)
if option in ['Y', 'N']:
break
if option == 'N':
code = 'Cancelled'
return
print('# Killing processes...')
for pid in pids:
posix.kill(pid, 9)
code = 'Complete'
return
else:
print('# No any process belonged to typed user is found.')
code = 'NoSolution'
return
def get_author_name():
import pwd,posix
user = pwd.getpwuid(posix.getuid())
name = user[4].split(',')[0]
if name is None or name == '': name = user[0]
return name
def main():
import optparse
import posix
if 'HOME' not in os.environ or os.environ['HOME'] == '' or os.environ['HOME'] == '/':
os.environ['HOME'] = pwd.getpwuid(posix.getuid())[7]
parser = optparse.OptionParser()
parser.add_option('-q', '--quiet', action='store_true', help='Silence output')
parser.add_option('-f', '--force', action='store_true', help='Force apply changes')
parser.add_option('--no-reinstall-broken', action='store_false', help="Don't reinstall locally modified rpms", dest='reinstall', default=True)
parser.add_option('-D', '--deploy', action='store_true', help='Deploy changes')
parser.add_option('-d', '--repo-path', help='Repo path')
parser.add_option('-b', '--backup', action='store_true', help='backup files')
parser.add_option('--noacl', action='store_true', help='Disable ACL support')
parser.add_option('--origin', help='URL for Git Repository origin')
parser.add_option('--branch', default='master', help='Default: %default')
parser.add_option('--diffs', action='store_true', help='Show diffs')
parser.add_option('--info', metavar='MACHINE', help='Dump deployment info for a machine')
parser.add_option('--assume-host', metavar='HOSTNAME', help='Assume the given hostname')
parser.add_option('--holdup-diffs', action='store_true', help='Show holdup diffs')
(options, args) = parser.parse_args()
if options.noacl:
os.environ['GITMAN_NOACL'] = '1'
# import ACL in the global namespace
# ACL module uses GITMAN_NOACL environment variable for conditional
# compilation
eval(
compile(
'from acl import ACL, has_xacl',
__file__,
'single'),
globals(),
globals())
if not options.repo_path:
parser.error('-d/--repo-path required')
if options.force and not options.deploy:
parser.error('Cannot force without deployment')
if options.info:
if options.quiet or options.deploy or options.backup or options.diffs or options.holdup_diffs:
parser.error('Cannot use -q/-D/-b/--diffs/--holdup-diffs with --info')
if options.diffs and options.holdup_diffs:
parser.error('--diffs and --holdup-diffs should not be used together')
verbose = not options.quiet and not options.info
gitman = GitMan(
os.path.abspath(options.repo_path),
options.origin,
options.branch,
assume_host=options.assume_host,
info=options.info)
if verbose:
ansi.writeout('Deployed version: %s' % gitman.deployed_version())
ansi.writeout('Newest version: %s' % gitman.latest_version())
ansi.writeout(' %d revisions between deployed and latest' %
gitman.undeployed_revisions())
if options.info is None:
holdups, verbose_info, failures = gitman.show_deployment(options.diffs, options.holdup_diffs)
if verbose:
ansi.writeout('\n'.join(verbose_info))
if failures:
ansi.writeout('${BRIGHT_RED}%s${RESET}' % '\n'.join(failures))
if len(holdups) > 0 and not options.force:
ansi.writeout('${BRIGHT_YELLOW}Force deployment needed:${RESET}')
ansi.writeout('${BRIGHT_RED}%s${RESET}' % '\n'.join(holdups))
if options.deploy:
sys.exit('Deployment skipped due to holdups...')
if options.deploy:
if failures:
sys.exit('Deployment skipped due to failures...')
gitman.deploy(backup=options.backup, force=options.force, reinstall=options.reinstall)
else:
print 'Showing deployment info for:', gitman.config['host_file']
gitman.dump_added()
#!/usr/bin/env python
import posix
import string
uid = posix.getuid()
login = ''
passwd = open('passwd')
for line in passwd.readlines():
rec = string.split(line, ':')
if int(rec[2]) == uid:
login = rec[0]
break
if login:
print "%d -> %s" % (uid, login)
else:
print "%d -> noname" % uid
def __init__(self, command_line, pacman_events_queue, interactive = False):
#self.pacman = pacman(self)
self.poll_object = select.poll()
self.pacman = pacman()
self.yesno = False
self.pacman_events_queue = pacman_events_queue
if interactive == True:
self.pacman.set_pipeit(True)
self.uid = posix.getuid()
# pid of pacman process
self.pid = 0
# catch SIGINT and call the handler
signal.signal(signal.SIGINT, self.sigint)
self.PS1 = "#"
self.greet = "Welcome to guzuta!\n"
self.prompt = self.PS1 + " "
self.prev_return = None
self.REASON_EXPLICIT = 0
# libpypac support {{{
self.server_dict, self.repo_list, self.noupgrade_list,\
self.ignore_list, self.hold_list = libpypac_0.read_conf()
# }}}
#self.opt_names = 'h:j:k:'
#self.long_opt_names = ''
#self.opts , self.long_opts = getopt.getopt(command_line, self.opt_names,
# self.long_opt_names)
# }}}
# commands and their description {{{
self.commands = {
'update': self.update,
'upd' : self.update,
'updatedb': self.updatedb,
'updatepkgs': self.updatepkgs,
'search': self.search,
's': self.search,
'localsearch': self.local_search,
'ls': self.local_search,
'repofiles': self.repofiles,
'rf': self.repofiles,
'install': self.install,
'localinfo': self.local_info,
'li': self.local_info,
'info': self.info,
'interactive': self.interactive,
'remove': self.remove,
'help': self.help,
'quit': self.quit,
'q': self.quit,
'version': self.version
}
self.comm_description = {
'update': 'update your system',
'upd' : 'same as \'update\'',
'updatedb': 'update pacman\'s repositories databases',
'updatepkgs': 'update packages based on the updated databases',
'search': 'search repositories',
's': 'same as \'search\'',
'localsearch': 'search locally installed packages',
'ls' : 'same as \'localsearch\'',
'repofiles': 'List all files in specified repositories',
'rf': 'same as \'repofiles\'',
'install' : 'install a package, must have root priviledges',
'localinfo': 'display information about a package',
'li': 'same as \'localinfo\'',
'info': 'display server\'s information about a package',
'remove' : 'remove a package, must have root priviledges',
'help' : 'this text',
'quit' : 'quit pycman',
'q' : 'same as \'quit\'',
'version': 'version'
}
def __is_root__(self): uid = posix.getuid() return uid == 0
#!/usr/bin/python
# yes this is fugly.
import posix
user = "******"
if posix.getuid() == 1005:
user = "******"
import dhm.sql.wrap, re
urlmatcher = re.compile(
r"\b(?P<url>(?P<scheme>http|https|ftp)://"
r"(?:(?P<login>(?P<username>[a-zA-Z0-9]+)(?::(?P<password>[A-Za-z0-9]+))?)@)?"
r"(?P<hostname>[A-Za-z0-9.-]+(?::(?P<port>[0-9]+))?)"
r"(?P<path>[A-Za-z0-9@~=?/.,&;#+-_%]*))")
print "Content-type: text/html\n"
print "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>"
print "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">"
print "<html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\">"
print " <head>"
print " <meta content=\"text/html; charset=utf-8\" http-equiv=\"Content-Type\" />"
print " <link href=\"linkurl.css\" type=\"text/css\" rel=\"stylesheet\" />"
print " <title>UrlLog for #koffie</title>"
print " </head>"
print " <body>"
print " <h1>UrlLog for #koffie</h1>"
print " <div id=\"content\">"
print " <table>"
print " <thead>"
page = self._retrieve_page(filename)
if not page.writable_for(self.user):
raise FtpResponse(550, 'Delete permission denied')
page.delete(self.user)
self.commit_transaction()
self.log_action('dele', [filename])
if __name__ == '__main__':
def arg(n, d):
if len(sys.argv) > n:
return sys.argv[n]
else:
return d
hostname = arg(1, '127.0.0.1')
portnumber = int(arg(2, '8021'))
Core.init_pyle()
print 'Listening on %s:%d' % (hostname, portnumber)
svr = FtpServer.FtpServer((hostname, portnumber), PyleFtpFS,
bannerText = 'Pyle FTP service ready.')
if posix.getuid() == 0:
print "Running as root, suing to " + Config.ftp_server_user
import pwd
try:
posix.setuid(pwd.getpwnam(Config.ftp_server_user)[2])
except KeyError:
print "Cannot su to " + Config.ftp_server_user + "!"
svr.serve_forever()
