def __init__(self, args, message_level="debug", parent=None) :
"""
Initialization method
@author: Roy Nielsen
"""
super(AdministratorCredentials, self).__init__(parent)
self.ui = Ui_AdministratorCredentials()
self.ui.setupUi(self)
self.args = args
self.message_level = message_level
self.username = ""
self.password = ""
self.cmd = ""
self.tmpDir = ""
self.progress_bar = QProgressDialog()
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(0)
self.progress_bar.setLabelText("Checking Password...")
#####
# Set up signals and slots
self.connect(self.ui.authUserButton, SIGNAL("clicked()"), self.isPassValid)
self.connect(self.ui.cancelButton, SIGNAL("clicked()"), self.rejectApp)
#####
# Commented out putting in the current logged in user as the default
# user - to make more Mac-like
#user = getpass.getuser()
#self.ui.adminName.setText(user)
log_message("Finished initializing AdministratorCredentials Class...", "debug", self.message_level)
def runWithTimeout(command, timout_sec, message_level="normal") :
"""
Run a command with a timeout - return:
Returncode of the process
stdout of the process
stderr of the process
timout - True if the command timed out
False if the command completed successfully
inspiration from: http://stackoverflow.com/questions/1191374/subprocess-with-timeout
@author: Roy Nielsen
"""
if isinstance(command, list) :
if not command :
log_message("Cannot run a command with a command list that is empty...", "normal", message_level)
return False, False, False, False
elif isinstance(command, basestring) :
if re.match("^\s*$", command) :
log_message("Cannot run a command with a command that is an empty string...", "normal", message_level)
return False, False, False, False
proc = Popen(command, stdout=PIPE, stderr=PIPE)
timeout = {"value" : False}
timer = threading.Timer(timout_sec, kill_proc, [proc, timeout])
timer.start()
stdout, stderr = proc.communicate()
timer.cancel()
return proc.returncode, stdout, stderr, timeout["value"]
def __partition(self):
"""
Not implemented on the Mac
"""
success = False
size = int(self.diskSize) / (2 * 1024)
cmd = [
self.diskutil, "partitionDisk", self.myRamdiskDev,
str(1), "MBR", "HFS+", "ramdisk",
str(size) + "M"
]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("*******************************************", "debug",
self.message_level)
log_message("retval: \"\"\"" + str(retval).strip() + "\"\"\"", "debug",
self.message_level)
log_message("reterr: \"" + str(reterr).strip() + "\"", "debug",
self.message_level)
log_message("*******************************************", "debug",
self.message_level)
log_message("Success: " + str(success) + " in __format", "debug",
self.message_level)
return success
def detach(device=" ", message_level="normal"):
"""
Eject the ramdisk
Detach (on the mac) is a better solution than unmount and eject
separately.. Besides unmounting the disk, it also stops any processes
related to the mntPoint
@author: Roy Nielsen
"""
success = False
if not re.match("^\s*$", device):
cmd = ["/usr/bin/hdiutil", "detach", device]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("*******************************************", "debug",
message_level)
log_message("retval: " + re.escape(str(retval).strip("\"")), "debug",
message_level)
log_message("reterr: " + re.escape(str(reterr).strip("\"")), "debug",
message_level)
log_message("*******************************************", "debug",
message_level)
log_message("Success: " + str(success) + " in eject", "debug",
message_level)
else:
raise Exception("Cannot eject a device with an empty name..")
return success
def checkIfUserIsLocalAdmin(user="", message_level="normal") :
"""
Check the local directory and see if a user is a local admin on the system.
command:
dscl . read /Groups/admin GroupMembership
above command returns:
GroupMembership: root rsn
Author: Roy Nielsen
"""
userFound = False
if not re.match("^\s*$", username) :
dsclCommand = ["/usr/bin/dscl", ".", "read", "/Groups/admin", "GroupMembership"]
log_message("About to run command: " + " ".join(dsclCommand), "debug", message_level)
(retval, reterr) = system_call_retval(dsclCommand, message_level)
#print "Retval: \"" + retval + "\""
if retval :
users = retval.split()[1:]
#print str(users)
for user in users :
if re.match("^%s$"%user, username) :
userFound = True
break
return userFound
def doesRestorePartitionExist(message_level="normal") :
"""
Checks for the existence of the restore partition
Author: Roy Nielsen
"""
log_message("Start checking for restore partition...", "debug", message_level)
doesItExist = False
#####
# Get valid users on the system, put them in a list
cmd = ["/usr/sbin/diskutil", "list", "/dev/disk0"]
(retval, reterr) = system_call_retval(cmd, message_level)
partitions = retval.split("\n")
for partition in partitions :
print partition
if re.match("^\s+\S+\s+\S+\s+Recovery HD\s+\S+\s+\S+\s+\S+", partition) :
doesItExist = True
break
else :
continue
log_message("Finishing check for restore parition with: " + str(doesItExist), "debug", message_level)
return doesItExist
def getResourcesDir() :
"""
Get the full path to the Resources directory of the current app
Author: Roy Nielsen
"""
# Gets the <app-path>/Contents/MacOS full path
selfdir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0])))
resource_dir = ""
parents = selfdir.split("/")
# Remove the "MacOS" dir from the list
parents.pop()
# Append "Contents" & "cmu" to the end of the list
#parents.append("Contents")
# Append "Resources" & "cmu" to the end of the list
parents.append("Resources")
# Join up the directory with slashes
resource_dir = "/".join(parents)
log_message("resources dir: " + str(resource_dir))
return resource_dir
def detachRamdisk(self, device, message_level="normal"):
if detach(device, message_level):
log_message("Successfully detached disk: " + str(device).strip(),
"verbose", message_level)
else:
log_message("Couldn't detach disk: " + str(device).strip())
raise Exception("Cannot eject disk: " + str(device).strip())
def setUp(self):
"""
Initializer
"""
self.setMessageLevel("normal")
self.subdirs = ["two", "three" "one/four"]
"""
Set up a ramdisk and use that random location as a root to test the
filesystem functionality of what is being tested.
"""
#Calculate size of ramdisk to make for this unit test.
size_in_mb = 100
self.mnt_pnt_requested = ""
self.success = False
self.mountPoint = False
self.ramdiskDev = False
self.mnt_pnt_requested = False
# get a ramdisk of appropriate size, with a secure random mountpoint
my_ramdisk = RamDisk(str(size_in_mb), self.mnt_pnt_requested, self.message_level)
(self.success, self.mountPoint, self.ramdiskDev) = my_ramdisk.get_data()
log_message("::::::::Ramdisk Mount Point: " + str(self.mountPoint), "debug", self.message_level)
log_message("::::::::Ramdisk Device : " + str(self.ramdiskDev), "debug", self.message_level)
if not self.success:
raise IOError
def detachRamdisk(self, device, message_level="normal"):
if detach(device, message_level):
log_message("Successfully detached disk: " + str(device).strip(),
"verbose", message_level)
else:
log_message("Couldn't detach disk: " + str(device).strip())
raise Exception("Cannot eject disk: " + str(device).strip())
def getStderr(self) :
"""
Getter for standard err
@author: Roy Nielsen
"""
log_message("Getting stderr...", "verbose", self.message_level)
return self.reterr
def __isMemoryAvailable(self) :
"""
Check to make sure there is plenty of memory of the size passed in
before creating the ramdisk
Best method to do this on the Mac is to get the output of "top -l 1"
and re.search("unused\.$", line)
@author: Roy Nielsen
"""
#mem_free = psutil.phymem_usage()[2]
#print "Memory free = " + str(mem_free)
success = False
self.free = 0
cmd = ["/usr/bin/top", "-l", "1"]
pipe = Popen(cmd, stdout=PIPE, stderr=STDOUT)
size = None
freeMagnitude = None
if pipe:
while True:
myout = pipe.stdout.readline()
if myout == '' and pipe.poll() != None:
break
line = myout.split()
# Get the last item in the list
found = line[-1]
almost_size = line[:-1]
size = almost_size[-1]
if re.search("unused", found) or re.search("free", found):
break
if size:
sizeCompile = re.compile("(\d+)(\w+)")
split_size = sizeCompile.search(size)
freeNumber = split_size.group(1)
freeMagnitude = split_size.group(2)
log_message("freeNumber: " + str(freeNumber), "debug", self.message_level)
log_message("freeMagnitude: " + str(freeMagnitude), "debug", self.message_level)
if re.match("^\d+$", freeNumber.strip()):
if re.match("^\w$", freeMagnitude.strip()):
success = True
if freeMagnitude:
if re.search("G", freeMagnitude.strip()):
self.free = 1024 * int(freeNumber)
self.free = str(self.free)
elif re.search("M", freeMagnitude.strip()):
self.free = freeNumber
return success
def tearDown(self):
"""
disconnect ramdisk
"""
if detach(self.ramdiskDev, self.message_level):
log_message(r"Successfully detached disk: " + str(self.ramdiskDev).strip(), "verbose", self.message_level)
else:
log_message(r"Couldn't detach disk: " + str(self.ramdiskDev).strip() + " : mntpnt: " + str(self.mntPoint))
raise Exception(r"Cannot eject disk: " + str(self.ramdiskDev).strip() + " : mntpnt: " + str(self.mntPoint))
def detachRamdisk(self, device):
# TODO: Add debug/verbose options
message_level = "normal"
if detach(device, message_level):
log_message(r"Successfully detached disk: " + str(device).strip(), "verbose", message_level)
else:
log_message(r"Couldn't detach disk: " + str(device).strip())
raise Exception(r"Cannot eject disk: " + str(device).strip())
def authenticate(user="", password="", message_level="normal") :
"""
Use pexpect to run "su" to run a command as another user...
Required parameters: user, password, command
inspiration from: http://stackoverflow.com/questions/12419198/python-subprocess-readlines-hangs
@author: Roy Nielsen
"""
authenticated = False
if re.match("^\s*$", user) or \
re.match("^\s*$", password):
log_message("Cannot pass in empty parameters...", "normal", message_level)
log_message("user = \"" + str(user) + "\"", "normal", message_level)
log_message("check password...", "normal", message_level)
return(255)
else :
output = ""
internal_command = ["/usr/bin/su", "-", str(user), "-c", "/bin/echo hello world"]
command = " ".join(internal_command)
log_message("command: " + str(command), "debug", message_level)
(master, slave) = pty.openpty()
process = Popen(internal_command, stdin=slave, stdout=slave, stderr=slave, shell=False)
#####
# Read password prompt
prompt = os.read(master, 512)
#####
# send the password
os.write(master, password + "\n")
#####
# catch the password
prompt = os.read(master, 512)
#####
# catch the output
output = os.read(master, 512)
os.close(master)
os.close(slave)
process.wait()
#print output.strip()
output = output.strip()
#####
# Check if valid or not...
if re.match("^su: Sorry", str(output)):
authenticated = False
elif re.match("^hello world", str(output)):
authenticated = True
else:
authenticated = False
log_message("Leaving authenticate with output of: \"" + str(output) + "\"", "debug", message_level)
return authenticated
def unmount(self) :
"""
Unmount the disk - same functionality as __eject on the mac
@author: Roy Nielsen
"""
success = False
if self.__eject() :
success = True
log_message("Success: " + str(success) + " in unmount", "debug", self.message_level)
return success
def _runcmd(self, cmd, err_message) :
"""
Run the command
@author Roy Nielsen
"""
success = False
try :
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
except Exception, err :
log_message(err_message + str(err))
def _runcmd(self, cmd, err_message):
"""
Run the command
@author Roy Nielsen
"""
success = False
try:
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
except Exception, err:
log_message(err_message + str(err))
def unmount(self):
"""
Unmount the disk - same functionality as __eject on the mac
@author: Roy Nielsen
"""
success = False
if self.__eject():
success = True
log_message("Success: " + str(success) + " in unmount", "debug",
self.message_level)
return success
def __getRandomizedMountpoint(self) :
"""
Create a randomized (secure) mount point - per python's implementation
of mkdtemp - a way to make an unguessable directory on the system
@author: Roy Nielsen
"""
success = False
try :
self.mntPoint = mkdtemp()
except Exception, err :
log_message("Exception trying to create temporary directory")
def __getRandomizedMountpoint(self):
"""
Create a randomized (secure) mount point - per python's implementation
of mkdtemp - a way to make an unguessable directory on the system
@author: Roy Nielsen
"""
success = False
try:
self.mntPoint = mkdtemp()
except Exception, err:
log_message("Exception trying to create temporary directory")
def checkIfUserIsAdmin(user="", message_level="normal") :
"""
Check if the passed in user is in the admin group - local or directory
service. The Admin group is group 80 on the Mac.
@author: Roy Nielsen
"""
if re.match("^\s*$", user) :
message = "Cannot check the group of a user string that is empty..."
log_message(message, "normal", message_level)
log_message("user: \"" + str(user) + "\"", "normal", message_level )
found = False
else:
found = False
retval = False
#####
# Looking for user in local directory as well as all attached
# directory services
cmd = ["/usr/bin/dscl", "/Search", "-read", "/Groups/admin", "GroupMembership"]
#retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
(retcode, retval, reterr, didTimeOut) = runWithTimeout(cmd, 15)
if didTimeOut :
cmd = ["/usr/bin/dscl", ".", "-read", "/Groups/admin", "GroupMembership"]
(retcode, retval, reterr, didTimeOut) = runWithTimout(cmd, 15)
if retval :
lines = retval.split("\n")
users = []
for line in lines :
#print "Line: " + str(line)
if re.match("^GroupMembership:\s+", line) :
members = line.split()[1:]
for member in members :
users.append(member)
#####
# Find unique members of the list
users = list(set(users))
#####
# Search the list for the passed in user
for member in users :
if re.match("^%s$"%user.strip(), member.strip()) :
#print "found... user: "******" = " + member
found = True
break
else :
found = False
return found
async def purger(self):
before_datetime = datetime.utcnow() - timedelta(
seconds=self.config.get('purge_messages_after'))
try:
log_message(
self.lfg_channel.guild,
f'purging messages from "{self.lfg_channel}#{self.lfg_channel.id}" older than {before_datetime}'
)
deleted_messages = await self.lfg_channel.purge(
before=before_datetime, limit=100, check=self.check_id)
except Exception as e:
print(e)
def __init__(self, parent=None) :
"""
Initialization method
Author: Roy Nielsen
"""
super(GeneralWarning, self).__init__(parent)
self.ui = Ui_GeneralWarning()
self.message_level = "debug"
self.ui.setupUi(self)
self.connect(self.ui.buttonBox, SIGNAL("accepted()"), self.accept)
log_message("Finished initializing NotOnCorrectDisk Class...", "debug", self.message_level)
def __init__(self, parent=None):
"""
Initialization method
Author: Roy Nielsen
"""
super(GeneralWarning, self).__init__(parent)
self.ui = Ui_GeneralWarning()
self.message_level = "debug"
self.ui.setupUi(self)
self.connect(self.ui.buttonBox, SIGNAL("accepted()"), self.accept)
log_message("Finished initializing NotOnCorrectDisk Class...", "debug",
self.message_level)
def __format(self) :
"""
Format the ramdisk
@author: Roy Nielsen
"""
success = False
cmd = ["/sbin/newfs_hfs", "-v", "ramdisk", self.myRamdiskDev]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("*******************************************", "debug", self.message_level)
log_message("retval: \"" + str(retval).strip() + "\"", "debug", self.message_level)
log_message("reterr: \"" + str(reterr).strip() + "\"", "debug", self.message_level)
log_message("*******************************************", "debug", self.message_level)
log_message("Success: " + str(success) + " in __format", "debug", self.message_level)
return success
def __partition(self) :
"""
Not implemented on the Mac
"""
success=False
size = int(self.diskSize)/(2*1024)
cmd = [self.diskutil, "partitionDisk", self.myRamdiskDev, str(1), "MBR", "HFS+", "ramdisk", str(size) + "M"]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("*******************************************", "debug", self.message_level)
log_message("retval: \"\"\"" + str(retval).strip() + "\"\"\"", "debug", self.message_level)
log_message("reterr: \"" + str(reterr).strip() + "\"", "debug", self.message_level)
log_message("*******************************************", "debug", self.message_level)
log_message("Success: " + str(success) + " in __format", "debug", self.message_level)
return success
def test_files_n_dirs(self):
"""
Should work when files exist in ramdisk.
"""
# Do file setup for this test
for subdir in self.subdirs:
dirpath = self.mountPoint + "/" + subdir
log_message("DIRPATH: : " + str(dirpath), "debug", self.message_level)
self.mkdirs(dirpath)
self.touch(dirpath + "/" + "test")
# Do the tests
for subdir in self.subdirs:
# CANNOT use os.path.join this way. os.path.join cannot deal with
# absolute directories. May work with mounting ramdisk in local
# relative directories.
self.assertTrue(os.path.exists(self.mountPoint + "/" + subdir + "/" + "test"))
def eject(self) :
"""
Eject the ramdisk
Detach (on the mac) is a better solution than unmount and eject
separately.. Besides unmounting the disk, it also stops any processes
related to the mntPoint
"""
success = False
cmd = [self.hdiutil, "detach", self.myRamdiskDev]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("*******************************************", "debug", self.message_level)
log_message("retval: \"" + str(retval).strip() + "\"", "debug", self.message_level)
log_message("reterr: \"" + str(reterr).strip() + "\"", "debug", self.message_level)
log_message("*******************************************", "debug", self.message_level)
log_message("Success: " + str(success) + " in eject", "debug", self.message_level)
return success
def __init__(self, command=[], message_level="normal") :
"""
Initialization method
"""
self.command = command
self.message_level = message_level
self.retout = None
self.reterr = None
threading.Thread.__init__(self)
if isinstance(self.command, types.ListType) :
self.shell = True
self.printcmd = " ".join(self.command)
if isinstance(self.command, types.StringTypes) :
self.shell = False
self.printcmd = self.command
log_message("Initialized runThread...", "normal", self.message_level)
def __create(self) :
"""
Create a ramdisk device
@author: Roy Nielsen
"""
success = False
cmd = [self.hdiutil, "attach", "-nomount", "ram://" + self.diskSize]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if reterr:
success = False
raise Exception("Error trying to create ramdisk(" + str(reterr).strip() + ")")
else:
self.myRamdiskDev = retval.strip()
log_message("Device: \"" + str(self.myRamdiskDev) + "\"", "debug", self.message_level)
success = True
log_message("Success: " + str(success) + " in __create", "debug", self.message_level)
return success
def touch(self, fname="", message_level="normal") :
"""
Python implementation of the touch command..
inspiration: http://stackoverflow.com/questions/1158076/implement-touch-using-python
@author: Roy Nielsen
"""
if re.match("^\s*$", str(fname)) :
log_message("Cannot touch a file without a filename....", "normal", self.message_level)
else :
try:
os.utime(fname, None)
except:
try :
open(fname, 'a').close()
except Exception, err :
log_message("Cannot open to touch: " + str(fname), "normal", self.message_level)
def processAdminUser(self) :
"""
Run Stonix as an admin user - load AdministratorCredentials dialog
with the current user as the default username.
Have AdministratorCredentials handle it's own buttons.
@author: Roy Nielsen
"""
retval = self.admin_creds.exec_()
self.admin_creds.raise_()
if retval == 1 :
self.accept
log_message("processAdminUser complete...", "verbose", self.message_level)
self.reject()
def runWithWaitTillFinished(command=[], message_level="normal") :
"""
Use subprocess to call a command and wait until it is finished before
moving on...
@author: Roy Nielsen
"""
if command :
if isinstance(command, types.ListType) :
printcmd = " ".join(command)
if isinstance(command, types.StringTypes) :
printcmd = command
proc = Popen(command, stdout=PIPE, stderr=PIPE)
proc.wait()
log_message("command: " + printcmd + " returned: " + str(proc.retcode), \
"verbose", self.message_level)
return (proc.retcode)
else :
log_message("Cannot run a command that is empty...", "normal", message_level)
def runMyThreadCommand(cmd=[], message_level="normal") :
"""
Use the RunThread class to get the stdout and stderr of a command
@author: Roy Nielsen
"""
retval = None
reterr = None
if cmd and message_level :
run_thread = RunThread(cmd, message_level)
run_thread.start()
run_thread.join()
retval = run_thread.getStdout()
reterr = run_thread.getStderr()
else :
log_message("Invalid parameters, please report this as a bug.")
return retval, reterr
def __remove_journal(self) :
"""
Having a journal in ramdisk makes very little sense. Remove the journal
after creating the ramdisk device
cmd = ["/usr/sbin/diskutil", "disableJournal", "force", myRamdiskDev]
using "force" doesn't work on a mounted filesystem, without it, the command
will work on a mounted file system
@author: Roy Nielsen
"""
success = False
cmd = [self.diskutil, "disableJournal", self.myRamdiskDev + "s1"]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("Success: " + str(success) + " in __remove_journal", "debug", self.message_level)
return success
def processAdminUser(self):
"""
Run Stonix as an admin user - load AdministratorCredentials dialog
with the current user as the default username.
Have AdministratorCredentials handle it's own buttons.
@author: Roy Nielsen
"""
retval = self.admin_creds.exec_()
self.admin_creds.raise_()
if retval == 1:
self.accept
log_message("processAdminUser complete...", "verbose",
self.message_level)
self.reject()
def runWithPty(command, message_level="normal") :
"""
Run a command with the pty...
@author: Roy Nielsen
"""
output = "ERROR..."
#####
# Check input
if command :
(master, slave) = pty.openpty()
#process = Popen(command, stdout=slave, stderr=slave, close_fds=True)
process = Popen(command, stdout=slave, stderr=slave)
output = ""
#temp = os.read(master, 10)
while True :
#r,w,e = select.select([master], [], [], 0) # timeout of 0 means "poll"
r,w,e = select.select([], [], [], 0) # timeout of 0 means "poll"
if r :
line = os.read(master, 512)
#####
# Warning, uncomment at your own risk - several programs
# print empty lines that will cause this to break and
# the output will be all goofed up.
#if not line :
# break
#print output.rstrip()
output = output + line
elif process.poll() is not None :
break
os.close(master)
os.close(slave)
process.wait()
#print output.strip()
output = output.strip()
log_message("Leaving runAs with: \"" + str(output) + "\"", "debug", message_level)
else :
log_message("Cannot run a command that is empty...", "normal", message_level)
return output
def __remove_journal(self):
"""
Having a journal in ramdisk makes very little sense. Remove the journal
after creating the ramdisk device
cmd = ["/usr/sbin/diskutil", "disableJournal", "force", myRamdiskDev]
using "force" doesn't work on a mounted filesystem, without it, the command
will work on a mounted file system
@author: Roy Nielsen
"""
success = False
cmd = [self.diskutil, "disableJournal", self.myRamdiskDev + "s1"]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("Success: " + str(success) + " in __remove_journal",
"debug", self.message_level)
return success
def __create(self):
"""
Create a ramdisk device
@author: Roy Nielsen
"""
success = False
cmd = [self.hdiutil, "attach", "-nomount", "ram://" + self.diskSize]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if reterr:
success = False
raise Exception("Error trying to create ramdisk(" +
str(reterr).strip() + ")")
else:
self.myRamdiskDev = retval.strip()
log_message("Device: \"" + str(self.myRamdiskDev) + "\"", "debug",
self.message_level)
success = True
log_message("Success: " + str(success) + " in __create", "debug",
self.message_level)
return success
def __format(self):
"""
Format the ramdisk
@author: Roy Nielsen
"""
success = False
cmd = ["/sbin/newfs_hfs", "-v", "ramdisk", self.myRamdiskDev]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("*******************************************", "debug",
self.message_level)
log_message("retval: \"" + str(retval).strip() + "\"", "debug",
self.message_level)
log_message("reterr: \"" + str(reterr).strip() + "\"", "debug",
self.message_level)
log_message("*******************************************", "debug",
self.message_level)
log_message("Success: " + str(success) + " in __format", "debug",
self.message_level)
return success
def system_call_retval(cmd="", message_level="normal", myshell=False) :
"""
Use the subprocess module to execute a command, returning
the output of the command
Author: Roy Nielsen
"""
retval = ""
reterr = ""
# mycmd = cmd.split()
if isinstance(cmd, types.ListType) :
printcmd = " ".join(cmd)
if isinstance(cmd, types.StringTypes) :
printcmd = cmd
try :
if myshell == False :
pipe = Popen(cmd, stdout=PIPE, stderr=PIPE)
elif myshell == True :
pipe = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=myshell)
else :
pipe = Popen(cmd, stdout=PIPE, stderr=PIPE)
(stdout_out, stderr_out) = pipe.communicate()
if stdout_out :
for line in stdout_out :
if line is not None :
line.strip("\n")
retval = retval + line
if stderr_out :
for line in stderr_out :
if line is not None :
line.strip("\n")
reterr = reterr + line
except ValueError, err :
log_message("system_call_retval - ValueError: " + str(err) + " command: " + printcmd, "normal", message_level)
def run(self):
if self.command :
try :
p = Popen(self.command, stdout=PIPE, stderr=PIPE, shell=self.shell)
except Exception, err :
log_message("Exception trying to open: " + str(self.printcmd), "normal", self.message_level)
log_message("Associated exception: " + str(err), "normal", self.message_level)
raise err
else :
try:
self.retout, self.reterr = p.communicate()
except Exception, err :
log_message("Exception trying to open: " + str(self.printcmd), "normal", self.message_level)
log_message("Associated exception: " + str(err), "normal", self.message_level)
raise err
else :
def eject(self):
"""
Eject the ramdisk
Detach (on the mac) is a better solution than unmount and eject
separately.. Besides unmounting the disk, it also stops any processes
related to the mntPoint
"""
success = False
cmd = [self.hdiutil, "detach", self.myRamdiskDev]
retval, reterr = Popen(cmd, stdout=PIPE, stderr=PIPE).communicate()
if not reterr:
success = True
log_message("*******************************************", "debug",
self.message_level)
log_message("retval: \"" + str(retval).strip() + "\"", "debug",
self.message_level)
log_message("reterr: \"" + str(reterr).strip() + "\"", "debug",
self.message_level)
log_message("*******************************************", "debug",
self.message_level)
log_message("Success: " + str(success) + " in eject", "debug",
self.message_level)
return success
async def on_message(message):
guild = message.guild
author = message.author
channel = message.channel
# check if message is not a DM and not created by a bot
if not isinstance(channel, discord.DMChannel) and not message.author.bot:
lfg_channel_id = config.get('lfg_channel_id')
# check if message was send to the lfg channel and does not contain an lfg
if (channel.id == config.get('lfg_channel_id')
) and not (command_prefix + lfg_command in message.content):
dm_no_lfg_command = config.get('dm_no_lfg_command')
await send_command_error_message(author, dm_no_lfg_command)
await message.delete()
log_message(
guild,
f'* message of "{author}" in "{channel}#{channel.id}" was deleted since it did not contain a command'
)
return
await lfg_bot.process_commands(message)
def __init__(self, args, message_level="debug", parent=None):
"""
Initialization method
@author: Roy Nielsen
"""
super(AdministratorCredentials, self).__init__(parent)
self.ui = Ui_AdministratorCredentials()
self.ui.setupUi(self)
self.args = args
self.message_level = message_level
self.username = ""
self.password = ""
self.cmd = ""
self.tmpDir = ""
self.progress_bar = QProgressDialog()
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(0)
self.progress_bar.setLabelText("Checking Password...")
#####
# Set up signals and slots
self.connect(self.ui.authUserButton, SIGNAL("clicked()"),
self.isPassValid)
self.connect(self.ui.cancelButton, SIGNAL("clicked()"), self.rejectApp)
#####
# Commented out putting in the current logged in user as the default
# user - to make more Mac-like
#user = getpass.getuser()
#self.ui.adminName.setText(user)
log_message("Finished initializing AdministratorCredentials Class...",
"debug", self.message_level)
def get_data(self):
"""
Getter for mount data, and if the mounting of a ramdisk was successful
"""
log_message("Success: " + str(self.success), "debug",
self.message_level)
log_message("Mount point: " + str(self.mntPoint), "debug",
self.message_level)
log_message("Device: " + str(self.myRamdiskDev), "debug",
self.message_level)
return (self.success, str(self.mntPoint), str(self.myRamdiskDev))
def isUserOnSystem(user="", message_level="normal") :
"""
Check if the passed in user is a local user on the system
Author: Roy Nielsen
"""
is_user_on_local_system = False
#####
# If the passed in user is empty or only spaces, return false.
if re.match("^\s*$", user) :
return is_user_on_local_system
#####
# Get valid users on the system, put them in a list
cmd = ["/usr/bin/dscl", "/Search", "list", "/Users"]
(retval, reterr) = system_call_retval(cmd, message_level)
systemUserList = retval.split("\n")
validSystemUserList = []
for systemUser in systemUserList :
if not re.match("^_.*", systemUser) and \
not re.match("^root$", systemUser) and \
not re.match("^nobody$", systemUser) and \
not re.match("^daemon$", systemUser) and \
not re.match("^\s*$", systemUser) :
log_message("Valid System User: "******"debug", message_level)
validSystemUserList.append(systemUser)
#####
# Check if the passed in user is a valid local user on the system
for systemUser in validSystemUserList :
if re.match("^%s$"%(systemUser), user) :
is_user_on_local_system = True
log_message("User: \"" + str(user) + "\" found on the system", "debug", message_level)
break
log_message("ivar = " + str(is_user_on_local_system), "debug", message_level)
return is_user_on_local_system