def get_verbosity():
"""
<Purpose>
Returns the current verbosity level:
4 - ULTRAVERBOSE aka DEBUG
3 - VERYVERBOSE aka DEBUG
2 - VERBOSE
1 - QUIET
0 - VERYQUIET
-1 - ABSOLUTE SILENCE
<Arguments>
None.
<Exceptions>
None.
<Side Effects>
None.
<Returns>
Returns the current verbosity level. See "Purpose", above.
"""
verbosity = arizonaconfig.get_option("verbose")
if verbosity == None:
arizonaconfig.init_options("arizonareport")
# stork default (--verbose)
return 2
else:
return verbosity
def set_verbosity(verbosity):
"""
<Purpose>
Sets the current verbosity level.
<Arguments>
verbosity:
The new verbosity level:
4 - ULTRAVERBOSE aka DEBUG
3 - VERYVERBOSE aka DEBUG
2 - VERBOSE
1 - QUIET
0 - VERYQUIET
-1 - ABSOLUTE SILENCE
<Exceptions>
None.
<Side Effects>
Changes the storkconfig "verbose" setting.
<Returns>
None.
"""
# check params
if not isinstance(verbosity, int):
raise TypeError, "The parameter 'verbosity' of the function 'set_verbosity' must be an integer."
if verbosity < -1 or verbosity > 4:
raise TypeError, "The parameter 'verbosity' of the function 'set_verbosity' must be from -1 to 4, inclusive."
if arizonaconfig.get_option("verbose") == None:
arizonaconfig.init_options("arizonareport")
arizonaconfig.set_option("verbose", verbosity)
def test_get_version(self):
# test version not set, result = None
arizonaconfig.init_options()
self.assertEqual(arizonaconfig.get_version(), None)
# test setting the version
arizonaconfig.init_options(version="1.2.3")
self.assertEqual(arizonaconfig.get_version(), "1.2.3")
def test_rank_packages(self):
self.reset_options()
try:
arizonaconfig.init_options("stork.py", configfile_optvar="configfile", version="2.0")
# Create two public/private key pairs
joe_privk = "/tmp/joe.privatekey"
arizonacrypt.generate_privatekey_fn(joe_privk)
joe_pubk_sl = arizonacrypt.extract_publickey_sl_from_privatekey_fn(joe_privk)
joe_pubk = arizonacrypt.sl_to_fn(joe_pubk_sl)
joe_pubk_string = arizonacrypt.publickey_sl_to_fnstring(joe_pubk_sl)
jim_privk = "/tmp/jim.privatekey"
arizonacrypt.generate_privatekey_fn(jim_privk)
jim_pubk_sl = arizonacrypt.extract_publickey_sl_from_privatekey_fn(jim_privk)
jim_pubk = arizonacrypt.sl_to_fn(jim_pubk_sl)
jim_pubk_string = arizonacrypt.publickey_sl_to_fnstring(jim_pubk_sl)
# Set up options so that we are "joe"
arizonaconfig.set_option("username","joe")
arizonaconfig.set_option("publickeyfile",joe_pubk)
arizonaconfig.set_option("tpdir","/tmp")
arizonaconfig.set_option("tpdtd","trustedpackages.dtd")
# Create example trustedpackages files
joe_tp_fn = "/tmp/joe."+joe_pubk_string+".tpfile"
jim_tp_fn = "/tmp/jim."+jim_pubk_string+".tpfile"
joe_tp_sl = ['<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>', '', '<TRUSTEDPACKAGES>', ' <FILE PATTERN="a.rpm" HASH="a8924367f832d012c56db" ACTION="allow" />', ' <USER PATTERN="foo*" USERNAME="******" PUBLICKEY="'+jim_pubk_string+'" ACTION="allow">', ' lasdfasdf asldf as df asfa sdf lasfadsfasfasdfakjlkjlkjl ', ' </USER>', ' <USER PATTERN="stork*" USERNAME="******" PUBLICKEY="'+jim_pubk_string+'" ACTION="allow" />', ' <FILE PATTERN="*.rpm" HASH="a89247f832d012c56db" ACTION="deny" />', ' <FILE PATTERN="*.deb" HASH="*" ACTION="deny" />', '</TRUSTEDPACKAGES>']
temp_joe_fn = arizonacrypt.sl_to_fn(joe_tp_sl)
os.rename(temp_joe_fn, joe_tp_fn)
arizonacrypt.XML_sign_file_using_privatekey_fn(joe_tp_fn, joe_privk)
jim_tp_sl = ['<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>', '', '<TRUSTEDPACKAGES>', ' <FILE PATTERN="*.rpm" HASH="joea8923732d012c56db" ACTION="allow"/>', ' <FILE PATTERN="*.rpm" HASH="joea237832d012c56db" ACTION="allow"/>', '</TRUSTEDPACKAGES>']
temp_jim_fn = arizonacrypt.sl_to_fn(jim_tp_sl)
os.rename(temp_jim_fn, jim_tp_fn)
arizonacrypt.XML_sign_file_using_privatekey_fn(jim_tp_fn, jim_privk)
self.assertEquals(rank_packages([("abc.rpm","joea8923732d012c56db","unknown")]),([], [], [('abc.rpm', 'joea8923732d012c56db', 'unknown')]))
self.assertEquals(rank_packages([("foo.rpm","joea8923732d012c56db","allow")]), ([('foo.rpm', 'joea8923732d012c56db', 'allow')], [], []))
self.assertEquals(rank_packages([("foo.deb","anyhash","deny")]), ([],[('foo.deb', 'anyhash', 'deny')], []))
self.assertEquals(rank_packages([("abc.rpm","joea8923732d012c56db","unknown"), ("foo.rpm","joea8923732d012c56db","allow"), ("foo.deb","anyhash","deny")]), ([ ("foo.rpm","joea8923732d012c56db","allow")],[ ("foo.deb","anyhash","deny")], [("abc.rpm","joea8923732d012c56db","unknown")]))
finally:
try:
# Clean up
os.remove(joe_tp_fn)
os.remove(joe_pubk)
os.remove(joe_privk)
os.remove(jim_tp_fn)
os.remove(jim_pubk)
os.remove(jim_privk)
except:
pass
def Main():
# usage: experiment1_client.py <remote_host> <remote_dir> <tmpfs_dir>
remote_host = sys.argv[1]
remote_dir = os.path.join( "/", sys.argv[2] )
tmpfs_dir = os.path.join( "/", sys.argv[3] )
if tmpfs_dir[-1] != "/":
tmpfs_dir += "/"
# get the remote file listing
f = urllib2.urlopen( "http://" + remote_host + ":8000" + os.path.join( remote_dir, "files.txt" ) )
files = []
dat = f.read()
f.close()
for f in dat.split("\n"):
files.append( os.path.join( remote_dir, f ) )
# get the remote file hashes
f = urllib2.urlopen( "http://" + remote_host + ":8000" + os.path.join( remote_dir, "hashes.txt" ) )
hashes = f.read().split("\n")
f.close()
# get the remote file sizes
f = urllib2.urlopen( "http://" + remote_host + ":8000" + os.path.join( remote_dir, "sizes.txt" ) )
sizes = f.read().split("\n")
f.close()
arizonaconfig.init_options("experiment2_client.py", configfile_optvar="configfile")
print "files: " + str(files)
print "sizes: " + str(sizes)
# empirically-calculated times for the 100MB file from experiment 1
#urllib2_time = 1.646
#arizonatransfer_time = 4.0068
#iftd_time = 3.9965
for i in xrange(len(files)-2, len(files)-1):
file = files[i]
size = sizes[i]
fhash = hashes[i]
# spawn a thread for urllib2 transfer, so we can block at the right time
#test_urllib2( file, remote_host, tmpfs_dir )
#os.popen("rm -rf " + file).close()
#test_arizonatransfer( file, fhash, size, remote_host, tmpfs_dir )
#os.popen("rm -rf " + file).close()
#os.popen("rm -rf " + tmpfs_dir + "*")
test_iftd( file, fhash, size, remote_host, tmpfs_dir )
os.popen("rm -rf " + file).close()
print ""
return 0
def Main():
# usage: experiment1_client.py <remote_host> <remote_dir> <tmpfs_dir>
remote_host = sys.argv[1]
remote_dir = os.path.join( "/", sys.argv[2] )
tmpfs_dir = os.path.join( "/", sys.argv[3] )
if tmpfs_dir[-1] != "/":
tmpfs_dir += "/"
# get the remote file listing
f = urllib2.urlopen( "http://" + remote_host + ":8000" + os.path.join( remote_dir, "files.txt" ) )
files = []
dat = f.read()
f.close()
for f in dat.split("\n"):
files.append( os.path.join( remote_dir, f ) )
# get the remote file hashes
f = urllib2.urlopen( "http://" + remote_host + ":8000" + os.path.join( remote_dir, "hashes.txt" ) )
hashes = f.read().split("\n")
f.close()
# get the remote file sizes
f = urllib2.urlopen( "http://" + remote_host + ":8000" + os.path.join( remote_dir, "sizes.txt" ) )
sizes = f.read().split("\n")
f.close()
arizonaconfig.init_options("experiment1_client.py", configfile_optvar="configfile")
print "files: " + str(files)
print "sizes: " + str(sizes)
for i in xrange(0, len(files)-1):
file = files[i]
size = sizes[i]
fhash = hashes[i]
print "Testing file " + str(file)
test_urllib2( file, remote_host, tmpfs_dir )
os.popen("rm -rf " + file).close()
test_arizonatransfer( file, fhash, size, remote_host, tmpfs_dir )
os.popen("rm -rf " + file).close()
os.popen("rm -rf " + tmpfs_dir + "*")
test_iftd( file, fhash, size, remote_host, tmpfs_dir )
os.popen("rm -rf " + file).close()
print ""
return 0
def test_config_prefix(self):
# Init config options...
arizonaconfig.init_options()
# Get a valid publickey file
priv_sl = arizonacrypt.generate_privatekey_sl()
pubkey_sl = arizonacrypt.extract_publickey_sl_from_privatekey_sl(priv_sl)
publickey_fn = arizonacrypt.sl_to_fn(pubkey_sl)
# Since I don't know the publickey, I assume this is okay if
# config_prefix() doesn't throw an exception
arizonaconfig.set_option("username","abc")
arizonaconfig.set_option("publickeyfile",publickey_fn)
storkusername.config_prefix()
# make sure that the embedded name is used if all are set.
arizonaconfig.set_option("embeddedusername","abc123")
#This is now hashed
#self.assertEquals(storkusername.config_prefix(),"abc123")
# unset options
arizonaconfig.set_option("username","")
arizonaconfig.set_option("publickeyfile","")
arizonaconfig.set_option("embeddedusername","")
# Nothing set, should throw TypeError
self.assertException(TypeError, storkusername.config_prefix())
# Only username, should throw TypeError
arizonaconfig.set_option("username","abc")
self.assertException(TypeError, storkusername.config_prefix())
# Only publickeyfile, should throw TypeError
arizonaconfig.set_option("username","")
arizonaconfig.set_option("publickeyfile",publickey_fn)
self.assertException(TypeError, storkusername.config_prefix())
# Invalid publickeyfile, should throw TypeError
arizonaconfig.set_option("username","abc")
arizonaconfig.set_option("publickeyfile","/bin/ls")
self.assertException(TypeError, storkusername.config_prefix())
# Missing publickeyfile, should throw TypeError
arizonaconfig.set_option("username","abc")
arizonaconfig.set_option("publickeyfile","/ajldf/asflas")
self.assertException(TypeError, storkusername.config_prefix())
os.remove(publickey_fn)
def download_repo_Tar():
# parse command line and options
args = arizonaconfig.init_options("s3downloadrepo.py", configfile_optvar="configfile", version="2.0")
arizonaconfig.set_option("awsbucket", "stork-repository-import")
storks3.init()
print "reading directory"
storks3.dumpdir()
print "getting repository tar files..."
for entry in storks3.readdir():
if not entry.key.startswith("reposplit"):
print " ignoring: " + entry.key
continue
fn = os.path.join("/mnt", entry.key)
print " getting " + entry.key + " to " + fn
try:
storks3.get_file(entry.key, fn)
except TypeError, e:
print "download of " + entry.key + " failed with error " + str(e) + " trying again"
try:
storks3.get_file(entry.key, fn)
except TypeError, e:
print "upload of " + entry.key + " failed with error " + str(e) + " gave up"
def main():
# use error reporting tool
storkerror.init_error_reporting("stork_nest_comm.py")
# process command line and initialize variables
args = arizonaconfig.init_options('stork_nest_comm.py', configfile_optvar='configfile', version=stork_nest_version.VERREL)
arizonareport.set_output_function(output_func_pid)
# there should not be any leftover options
if args:
arizonareport.send_error(0, "Arguments not understood: " + str(args))
sys.exit(1)
arizona_share.init()
# run as a daemon
if arizonaconfig.get_option("daemon"):
arizonageneral.make_daemon("stork_nest_comm.py")
# display ready message
if not arizonaconfig.get_option("daemon"):
print "Ready for connections..."
# infinite loop (daemon must keep running)
#while True:
# Handle incoming connections
#try:
arizonacomm.listen("localhost", arizonaconfig.get_option("listenport"), handle_connection)
def test_set_option(self):
# try to set option when arizonaconfig hasn't been initialized
reload(arizonaconfig)
self.assertException(UnboundLocalError, arizonaconfig.set_option, "xyz", "abc")
self.set_cmdline([])
arizonaconfig.init_options()
# test invalid/missing params
self.assertException(TypeError, arizonaconfig.set_option, True, "123")
self.assertException(TypeError, arizonaconfig.set_option, "missing")
# try setting option which does not yet exist (create new option)
arizonaconfig.set_option("xyz", "abc")
self.assertEqual(arizonaconfig.get_option("xyz"), "abc")
# change existing option
self.assertEqual(arizonaconfig.get_option("digest"), "sha1")
arizonaconfig.set_option("digest", "pgp")
self.assertEqual(arizonaconfig.get_option("digest"), "pgp")
def GroupFileParse(dtd, group_file_name):
"""Creates the parser for the groups.xml file and parses it.
Returns a dictionary of group members."""
arizonaconfig.init_options('arizonagroup.py', usage=usagemsg)
#print arizonaconfig.get_option("usesignedfiles")
try:
# SMB - storkpackagelist.find_file() already checked the signature for
# us, so we can assume the file is valid and extract the contents
if arizonaconfig.get_option('usesignedfiles'):
#print "Reading signed file"
temp_contents = arizonacrypt.XML_retrieve_originalfile_from_signedfile(group_file_name)
#print temp_contents
else:
#print "Reading unsigned file"
temp_contents = group_file_name
except TypeError, e:
arizonareport.send_error(0, str(e))
sys.exit(1)
def test_package_exists(self):
self.reset_options()
# should return None if None is passed:
self.assertEquals(None, storkpackagelist.package_exists(None))
# pass invalid input
self.assertRaises(Exception, storkpackagelist.package_exists, 3.0)
# ON HOLD-- docs may be wrong
## pass names that are not known packages without initializing the options.
## Should return None:
#self.assertEquals(None, storkpackagelist.package_exists(" "))
#self.assertEquals(None, storkpackagelist.package_exists("some unknown package"))
# pass names that are not known packages, but initialize options first
# since arizonaconfig.get_options() is used:
prefix = os.environ.get("TESTPREFIX")
arizonaconfig.init_options("storkpackagelist.py", alt_paths=[prefix], version='2.0')
#arizonaconfig.set_option("localpdir", ["some string"]) <- this should not be set manually
# now set the "localinfo" variable and call init().
arizonaconfig.set_option("localinfo", "/usr/local/stork/var/packageinfo")
arizonaconfig.set_option("pdir", ["nr06.cs.arizona.edu/PlanetLab/V3/dist"])
arizonaconfig.set_option("repinfo", ["nr06.cs.arizona.edu/packageinfo"])
storkpackagelist.init()
self.assertFalse(storkpackagelist.package_exists("hello"))
self.assertFalse(storkpackagelist.package_exists("some unknown name"))
self.assertFalse(storkpackagelist.package_exists("gnuchess"))
self.assertFalse(storkpackagelist.package_exists(" "))
# this test was from Jeffry Johnston.
# NOTE that currently, it only works if the metadata exists on the system.
arizonaconfig.init_options("storkpackagelist.py", alt_paths = [prefix], version = '2.0')
arizonaconfig.set_option("updatedb", False)
arizonaconfig.set_option("pdir", ["nr06.cs.arizona.edu/PlanetLab/V3/dist/"])
arizonaconfig.set_option("repinfo", ["nr06.cs.arizona.edu/packageinfo"])
storkpackagelist.init()
self.assertTrue(storkpackagelist.package_exists("gnuchess"))
def test_get_sections(self):
# try to get option when arizonaconfig hasn't been initialized
reload(arizonaconfig)
self.assertEqual(arizonaconfig.get_sections("digest"), [])
# pass bad/missing params (string expected)
self.assertException(TypeError, arizonaconfig.get_sections)
self.assertException(TypeError, arizonaconfig.get_sections, None)
self.assertException(TypeError, arizonaconfig.get_sections, True)
self.assertException(TypeError, arizonaconfig.get_sections, ["digest"])
# empty string should be okay
self.assertEqual(arizonaconfig.get_sections(""), [])
# with config file, no command line
self.set_cmdline([])
arizonaconfig.init_options(TEST_FILE, configfile_optvar='configfile')
self.assertEqual(arizonaconfig.get_sections("rv0"), [])
self.assertEqual(arizonaconfig.get_sections("rv1"), ["rep1", "rep3"])
self.assertEqual(arizonaconfig.get_sections("rv2"), ["rep2"])
self.assertEqual(arizonaconfig.get_sections("rv3"), ["rep1", "rep2"])
def main():
#should work with the current arizonaconfig code
configlib.init_options(configfile_optvar='configfile')
if get_option("storknestupdatedebug").strip().lower()=="true":
debugmode=True
else:
debugmode=False #despite being declared above, this is still necessary...
#use config settings to override settings from the config file
configlib.set_option('transfermethod',get_option("storknestupdatetransfermethods"))
if debugmode:
print "Transfermethod changed:",get_option("transfermethod")
if not debugmode:
arizonageneral.make_daemon("stork_nest_update.py")
if debugmode:
print "Configuration loaded.\nDaemonizing blocked by debugmode."
ldaemon=ListenerDaemon(get_option("storknestupdatelistenerport"), 10, True, debugmode)
udaemon=UpdateDaemon(ldaemon.send, debugmode)
pdaemon=NestPsEPRDaemon(None, None, udaemon, debugmode)
udaemon.start()
if debugmode:
print "All Deamons started."
def main():
# get command line and config file options
args = arizonaconfig.init_options("profileview.py", usage="profileview.py [options] filename", version="2.0")
if len(args) != 1:
arizonaconfig.print_help()
sys.exit(1)
stats = hotshot.stats.load(args[0])
stats.strip_dirs()
stats.sort_stats("time", "calls")
numstats = arizonaconfig.get_option("numstats")
if numstats == 0:
stats.print_stats()
else:
stats.print_stats(numstats)
def main():
# process command line arguments
args = arizonaconfig.init_options("storkmetafileupdate.py", configfile_optvar="configfile", version="2.0")
if len(args) < 1:
arizonareport.send_error(1, "Usage: storkextractmeta.py [OPTION(s)] tarball(s)")
sys.exit(1)
# prepare metafile directory and filename
metafiledir = arizonaconfig.get_option("metafiledir")
if metafiledir[-1] != "/": # add trailing slash if there isn't one
metafiledir += "/"
if not os.path.isdir(metafiledir):
try:
os.makedirs(metafiledir)
except OSError, e:
arizonareport.send_error(1, "Could not create metafile directory: " + metafiledir + " (" + str(e) + ")")
sys.exit(1)
def main():
args = arizonaconfig.init_options("storkpseprattempt.py", configfile_optvar="configfile", version="2.0")
# SMB: doubled it to 32 seconds
wait = 32;
global pid_file;
# SMB: changed filename to psepr.pid to disambiguate from other pid files
pid_file = "/repository/psepr.pid"
# SMB: removed check for existing pid file, since it appears to be done
# already by attemptpsepr.init
pid = os.getpid()
pid_file_obj = open(pid_file, "w")
pid_file_obj.write(str(pid))
pid_file_obj.close()
if len(args) < 3:
print "incorrect usage."
os.unlink(pid_file)
sys.exit(-1)
# print args[0]
# print args[1]
# print args[2]
pseprpath = "/usr/local/stork/bin/pseprpusher.py"
if not os.path.isfile(pseprpath):
print "could not find "+pseprpath
command = pseprpath + " " + args[0] + " " + args[1] + " " + args[2]
finished_ok = False
finished_ok ,status = arizonageneral.system_timeout_backoff(command, 5, wait, 9)
if finished_ok:
print command + " FINISHED OK"
else:
print command + " FAILED"
os.unlink(pid_file)
def init():
"""
<Purpose>
Processes and handles some command line arguments.
<Arguments>
None.
<Exceptions>
None.
<Side Effects>
None.
<Returns>
A list of unhandled command line arguments.
"""
# get command line and config file options
args = arizonaconfig.init_options('storkquery.py', configfile_optvar='configfile', version='2.0')
# init package lists
storkpackagelist.init()
"""global storkpm
#### Set up the packaging tool
# Right now only use rpm... Could change this to work with deb
if glo_options.pmtype=='rpm':
import storkrpm as storkpm
else:
arizonareport.send_error(0, "Unknown package manager '" +
glo_options.pmtype + "'")
sys.exit(1)
# Figure out what the package tool can do...
arizonareport.send_out(2, "Fetching information about our packaging " +
"tool (" + glo_options.pmtype + ")")
storkpm.init_package_manager()
"""
return args
def main():
args = arizonaconfig.init_options('replace.py', usage='usage: replace.py [options] FILE...', version='2.0')
find_text = arizonaconfig.get_option("findstr")
if find_text == None:
print "Must specify string to find. See --help."
return
replace_text = arizonaconfig.get_option("replacestr")
if replace_text == None:
print "Must specify replacement string. See --help."
return
(status, failed_list) = arizonageneral.text_replace_files_in_fnlist(find_text, replace_text, args)
if not status:
print "Cannot locate or access: " + " ".join(failed_list)
return
def main():
# prepare error reporting tool
storkerror.init_error_reporting("storklog.py")
# parse command line and options
args = arizonaconfig.init_options(module="storklog.py", version="2.0")
# check for root
if os.geteuid() > 0:
arizonareport.send_error(0, "You must be root to run this program...")
sys.exit(1)
# grab the storklog mutex. This prevents multiple copies of storklog from
# running at the same time.
storklogLock = arizonageneral.mutex_lock("storklog", arizonaconfig.get_option("lockdir"))
if not storklogLock:
arizonareport.send_error(0, "Another copy of storklog is already running...")
sys.exit(0)
# rotate, upload, and delete logs
rotate_logs()
def main():
args = arizonaconfig.init_options("storkvalidatepublickey.py")
if len(args) != 1:
arizonareport.send_error(1, "usage: storkvalidatepublickey.py <potential public key>")
sys.exit(1)
if not os.path.isfile(args[0]):
arizonareport.send_error(1, "error: " + args[0] + " is not a file.")
sys.exit(1)
# use arizonacrypt to see if this filecontains a valid pubkey
(isvalidkey, keycontents) = arizonacrypt.publickey_fn_to_sl(args[0],"rsa")
if( isvalidkey ):
arizonareport.send_out(1, args[0] + " is a valid public key file")
sys.exit(0)
else:
arizonareport.send_error(1, args[0] + " is NOT a valid public key file")
sys.exit(1)
def main():
# parse command line and options
args = arizonaconfig.init_options("s3uploadrepo.py", configfile_optvar="configfile", version="2.0")
if len(args) == 0:
help()
if args[0] == "downloadrepotar":
download_repo_tar()
elif args[0] == "uploadrepotar":
upload_repo_tar()
elif args[0] == "destroy":
destroy_repo()
elif args[0] == "dump":
dump_repo()
elif args[0] == "listbuckets":
list_buckets()
elif args[0] == "downloadrepo":
download_repo()
elif args[0] == "putfile":
put_file(args[1])
else:
help()
lo.close()
except Exception, e:
lo=open(self.log,"a")
lo.write(str(currenttime())+":")
lo.write("TorrentMakerTimer - "+str(e)+'\n')
lo.close()
if __name__ == '__main__':
uiname = 'btlaunchmany'
defaults = get_defaults(uiname)
set=defaultset[:]
#conffile=None
#if os.path.isfile(glo_confname):conffile=glo_confname
arizonaconfig.init_options(sys.argv[0],'.',[],None,"arizonabittorrentshareconfig")#conffile)
set[0]=get_option("arizonabittorrentcheckinterval",set[0])
set[1]=get_option("arizonabittorrentfiledir",set[1])
set[2]=get_option("arizonabittorrentupdatedir",set[2])
set[3]=get_option("arizonabittorrentuploadrate",set[3])
set[4]=get_option("arizonabittorrentsharing",str(set[4])).lower().strip()=="true"
set[5]=get_option("arizonabittorrenttrackerhost",set[5])
glo_possibleserverdomain=set[5]
set[6]=get_option("arizonabittorrenttrackerport",set[6])
set[8]=get_option("arizonabittorrentsharelogging",set[8])
set[9]=get_option("arizonabittorrentsharelogginginterval",set[9])
if get_option("arizonabittorrentsharing","true").lower()=="false":
#this program should not be running...
sys.exit()
import os
import storkvalidatepubkey
class test(arizonaunittest.TestCase):
#Test the only method in the test, which checks via arizonacrypt whether the key is valid
def test_main(self):
#Test with blank filename
self.set_cmdline([""])
self.assertException(SystemExit,storkvalidatepubkey.main)
self.assertEquals( "error: is not a file.", arizonareport.message)
#Test a valid key generated with storkutil.py
self.set_cmdline(["test/testkeys.publickey"])
self.assertException(SystemExit,storkvalidatepubkey.main)
self.assertEquals("test/testkeys.publickey is a valid public key file",arizonareport.message)
#Test invalid key, some bytes deleted in a valid key
self.set_cmdline(["test/invalid.publickey"])
self.assertException(SystemExit,storkvalidatepubkey.main)
self.assertEquals("test/invalid.publickey is NOT a valid public key file",arizonareport.message)
#Test invalid key, some bytes changed in valid key
self.set_cmdline(["test/invalid2.publickey"])
self.assertException(SystemExit,storkvalidatepubkey.main)
self.assertEquals("test/invalid2.publickey is NOT a valid public key file",arizonareport.message)
if __name__=='__main__':
arizonaconfig.init_options()
arizonaunittest.main()
def main():
#get command line options
args = arizonaconfig.init_options("storkverifysignedfile.py", configfile_optvar="configfile", version="2.0")
if len(args) != 1:
arizonareport.send_error(1, "Usage: storkverifysignedfile.py [OPTION(s)] signedfile")
sys.exit(-1)
tmpuploaddir = arizonaconfig.get_option("tmpuploaddir")
endfiledir = arizonaconfig.get_option("endfiledir")
if tmpuploaddir[-1] != "/": # add trailing slash if there isn't one
tmpuploaddir += "/"
if not os.path.isdir(tmpuploaddir):
arizonareport.send_out(1, tmpuploaddir + " does not exist, could not verify authenticity of "+args[0])
sys.exit(-1);
if endfiledir[-1] != "/": # add trailing slash if there isn't one
endfiledir += "/"
if not os.path.isdir(endfiledir):
arizonareport.send_out(1, endfiledir + " does not exist, could not verify authenticity of "+args[0])
sys.exit(-1);
filename = args[0];
timestamp1 = verify_file(filename, tmpuploaddir)
if timestamp1 > 0:
arizonareport.send_out(2, "File " + filename + " has been verified.")
else:
arizonareport.send_out(2, "File " + filename + " has a bad signature.")
sys.exit(1)
#check to see if there is another copy of
#this tp file in the tp file dir
if os.path.isfile(endfiledir+filename):
#there is another copy, get the timestamp
timestamp2 = verify_file(filename,endfiledir)
if timestamp2 < 0:
#something is wrong... once validily signed tp file
#is no longer valid... should I report this to someone?
arizonareport.send_out(0, "Once valid signed file " + endfiledir+filename + " is no longer valid.")
sys.exit(-1)
# now check to see if the new file has a newer timestamp then the old
# file... if it does, replace it
if timestamp1 > timestamp2:
arizonareport.send_out(2,"Overwriting " + filename + " with newer version of tp file...")
move_file(tmpuploaddir+filename,endfiledir+filename)
sys.exit(2);
# the file they tried to upload is older then then the file in the repository... so dont
# replace it
else:
arizonareport.send_out(2,"Will not overwrite " + filename + " with older or same version of uploaded file.")
sys.exit(3)
else:
# this tp file is not in the repository yet.... move it there now
arizonareport.send_out(2,"Moving " + filename + " to the tp file dir now...")
move_file(tmpuploaddir+filename,endfiledir+filename)
sys.exit(4)
def main():
global done, pipe
# parse command line and options
args = arizonaconfig.init_options(module="stracedaemon.py", version="2.0")
# run as a daemon
arizonageneral.make_daemon(DAEMONNAME)
# make it easy to kill the daemon
outfile = open(DAEMONPIDFILE, "w")
outfile.write(str(os.getpid()))
outfile.close()
# check to make sure the service we want to monitor exists
if not os.path.exists(INPUT_PIDFILE):
# sleep a few seconds and try again, just in case stork_nest_comm
# was launched, but has not yet written its pidfile
time.sleep(10)
if not os.path.exists(INPUT_PIDFILE):
# raise an exception to generate an error report
raise Exception, "the stork nest is not running"
# the following does not happen
arizonareport.send_error(0, "the stork nest is not running")
sys.exit(-1)
# get the pid we want to monitor from INPUT_PIDFILE
input_pidfile = open(INPUT_PIDFILE)
input_pid = input_pidfile.read()
input_pidfile.close()
arizonareport.send_out(0, "monitoring pid " + str(input_pid))
command = '(strace -f -ttt -e trace=network -p ' + str(input_pid)+ ' 2>&1 1>/dev/null)' + \
' | (egrep "AF_INET")'
# ' | egrep "connect\([0-9]+, \{sa_family=AF_INET.* = 0" 2>/dev/null' + \
# ' | fgrep -v "127.0.0.1"' + \
# ' | awk \'"*" { gsub("(\\[pid )|(\\])|(sin_port=htons\\()|(\\),)|(sin_addr=inet_addr\\(.)|(.\\)\\},)","", $0); print $1 " " $2 " " $5 " " $6; }\''
arizonareport.send_out(0, "executing: " + command)
# set up I/O
# XXX run the command
pipe = os.popen(command, "r")
# set up hangup signal handler
signal.signal(signal.SIGHUP, handler_sighup)
lasttime = 0
while not done:
# is it time to change log file?
currtime = time.time()
if currtime - lasttime >= arizonaconfig.get_option("interval"):
lasttime = currtime
# build filename
filename = None
try:
filename = arizonageneral.gethostname()
except:
pass
if filename == None:
filename = "unknown_host"
try:
username = arizonageneral.getusername()
except:
username = "******"
filename = arizonaconfig.get_option("logdir") + "/" + filename \
+ "^" + username + "^" + str(currtime) + LOGSUFFIX
# close old file
try:
outfile.flush()
except:
pass
try:
outfile.close()
except:
pass
# create current.packetlog file
try:
tempfile = open(arizonaconfig.get_option("logdir") + "/" + CURRENTFILE, "w")
tempfile.write(filename)
tempfile.close()
except:
pass
# open new file
try:
outfile = open(filename, "a")
except:
pass
# read stdin
if not done:
try:
line = pipe.readline()
except:
done = True
# write to file
if not done:
try:
outfile.write(line)
except:
pass
if not done:
try:
outfile.flush()
except:
pass
#dont eat up cycles
time.sleep(1)
# clean up
try:
outfile.close()
except:
pass
os.system("/bin/rm -f " + DAEMONPIDFILE + " &> /dev/null")
self.assertTrue(os.path.isfile("../test/PyXML-0.8.3-6.i386.rpm"))
tl = storktransaction.tl_create()
storktransaction.tl_install(tl,"../test/PyXML-0.8.3-6.i386.rpm")
storkrpm.execute(tl)
#------------------------------------------------------------------
# package_list -> void, IOError, NameError, TypeError
#------------------------------------------------------------------
def test_remove(self):
pass
"""
self.assertException(TypeError, arizonaconfig.init_options, 100)
self.set_cmdline(["--help"])
self.reset_stdout()
self.reset_stderr()
reload(arizonaconfig)
"""
# Run tests
if __name__ == '__main__':
storkrpm.initialize()
arizonaconfig.init_options("storkrpmTest")
arizonaconfig.set_option("transfermethod", ['http', 'ftp'])
arizonaunittest.main()
def main():
global done, pipe
# parse command line and options
args = arizonaconfig.init_options(module="tcpdumpdaemon.py", version="2.0")
# run as a daemon
arizonageneral.make_daemon("tcpdumpd")
# make it easy to kill the daemon
outfile = open("/tmp/tcpdump.pid", "w")
outfile.write(str(os.getpid()))
outfile.close()
# set up I/O
pipe = os.popen("/usr/sbin/tcpdump -tt -v -nn 2> /dev/null", "r")
# set up hangup signal handler
signal.signal(signal.SIGHUP, handler_sighup)
lasttime = 0
while not done:
# is it time to change log file?
currtime = time.time()
if currtime - lasttime >= arizonaconfig.get_option("interval"):
lasttime = currtime
# build filename
filename = None
try:
filename = arizonageneral.gethostname()
except:
pass
if filename == None:
filename = "unknown_host"
try:
username = arizonageneral.getusername()
except:
username = "******"
filename = arizonaconfig.get_option("logdir") + "/" + filename \
+ "^" + username + "^" + str(currtime) + "^packetlog"
# close old file
try:
outfile.flush()
except:
pass
try:
outfile.close()
except:
pass
# create current.packetlog file
try:
tempfile = open(arizonaconfig.get_option("logdir") + "/current.packetlog", "w")
tempfile.write(filename)
tempfile.close()
except:
pass
# open new file
try:
outfile = open(filename, "a")
except:
pass
# read stdin
if not done:
try:
line = pipe.readline()
except:
done = True
# write to file
if not done:
try:
outfile.write(line)
except:
pass
if not done:
try:
outfile.flush()
except:
pass
#dont eat up cycles
time.sleep(1)
# clean up
try:
outfile.close()
except:
pass
os.system("/bin/rm -f /tmp/tcpdump.pid &> /dev/null")
pass
def main(args):
# check command line args
if len(args) < 2:
arizonareport.send_error(2, "Usage: storkextractmeta.py [OPTION(s)] file(s) metadestdir")
sys.exit(1)
# nestrpm is unnecessary and prints some useless warnings, so remove it
# from the list of package managers
packmans = arizonaconfig.get_option("packagemanagers")
if 'nestrpm' in packmans:
packmans = [packman for packman in packmans if packman != "nestrpm"]
arizonaconfig.set_option("packagemanagers", packmans)
# extract the metadata
extract_metadata(args[:-1], args[-1])
# Start main
if __name__ == "__main__":
args = arizonaconfig.init_options("storkextractmeta.py", configfile_optvar="configfile", version="2.0")
main(args)
# The empty string
self.assertException(arizonageneral.Exception_Data ,storktar.remove, [""])
# invalid package name
self.assertException(arizonageneral.Exception_Data ,storktar.remove, ["dhsfkj"])
def __check_files(self, pack):
(out, err, status) = arizonageneral.popen5("tar -Pztf " + pack)
if out[0][0] != "/":
path_head = os.getenv("HOME") + "/"
else:
path_head = ""
for afile in out:
afile = afile.strip('\n')
if not os.path.exists(path_head + afile):
print "\nsome of files on package " + pack + " has not installed"
os._exit(1)
#=====================================================================
# Run tests
#=====================================================================
if __name__=='__main__':
arizonaconfig.init_options("tarpackinfopath")
arizonaconfig.set_option("tarpackinfopath", "/tmp/tar_packinfo")
arizonaunittest.main()
