def __init__( self, parsetFilename, partition, testname ): self.partition = partition self.testname = testname # configure the correlator before the parsets are added such that they will use the right paths testfilename = self.testname for c in " :": testfilename = testfilename.replace(c,"_") self.logdir = "%s/%s" % (Locations.files["logdir"],testfilename) self.results = { "started": False, "terminated": False, "logdir": self.logdir, } self.parset = Parset() self.olapparset_filename = "%s/OLAP.parset" % (Locations.files["configdir"],) self.rtcpparset_filename = parsetFilename for f in [self.olapparset_filename, self.rtcpparset_filename]: self.parset.readFile( Locations.resolvePath( f ) )
def __init__(self, no_of_lives=4, score=0): #Setup some Game constants self.GAME_LENGTH = 60000.0 # 60 seconds self.GAME_TIME_BONUS = 1000 #maximum points available as time bonus points self.FLY_POINTS = 100 self.HOME_POINTS = 250 self.MOVE_POINTS = 10 #Create frogs and other objects and package them in lists frog_x_positions = [x * 50 for x in range(no_of_lives)] self.frogs = [ Moveable(x, 430, 'data/frog.png', 'data/splat.png', 0) for x in frog_x_positions ] self.frog = self.frogs[0] self.frog.x, self.frog.y = 305, 405 cars = [ Moveable(x, 300, 'data/car.png', None, 3) for x in range(0, 640, 213) ] lorries = [ Moveable(x, 350, 'data/blue-lorry.png', None, 2) for x in [200, 520] ] bikes = [ Moveable(x, 250, 'data/bike.png', None, 7) for x in [300, 620] ] self.vehicles = [] self.vehicles.extend(cars) self.vehicles.extend(lorries) self.vehicles.extend(bikes) logs1 = [ RiverMoveable(x, 50, 'data/log.png', None, -4) for x in [0, 128, 256, 384, 512] ] turtles = [RiverMoveable(x, 100, 'data/turtle.png', 'data/sink_turtle.png', 2, 0.75)\ for x in [50, 178, 306,434,562]] logs2 = [ RiverMoveable(x, 150, 'data/log.png', None, -4) for x in [0, 128, 256, 384, 512] ] self.river_objects = [] self.river_objects.extend(logs1) self.river_objects.extend(turtles) self.river_objects.extend(logs2) bank_locations = [ Locations(x, y) for (x, y) in [(210, 15), (360, 15), (510, 15), (50, 15), ( 70, 215), (220, 215), (380, 215), (530, 215), (200, 415), (440, 415)] ] self.homes = [Home(x, 0) for x in [50, 200, 350, 500]] self.fly_locations = [] self.fly_locations.extend(bank_locations) self.croc_locations = self.homes self.croc_locations.append(Locations(-50, -50)) # Add an offscreen location self.flies = [TimedMoveable(x, 15, 'data/fly.png', None, None, 1.5, self.fly_locations)\ for x in [210, 360, 510]] self.crocs = [ TimedMoveable(50, 0, 'data/croc.png', None, None, 3, self.homes) ] splash = ['data/splash1.png', 'data/splash2.png', 'data/splash3.png'] self.animations = [Animation(splash, 150)] self.score = score self.no_of_lives = no_of_lives '''game_data = {'frog':frog,'frogs':frogs, 'vehicles':vehicles, 'river_objects':river_objects,\
from Locations import Locations from Product import Product from Url import Url from cheapestprice import cheapest_price as cheapest from sql import add_to_table as db if (__name__ == "__main__"): # set the loop to run by default loopcond = True while (loopcond): # first arg is the product name product = input("Enter a product: ") # get the locations and location ids l = Locations() provinces = l.get_provinces() province_ids = l.get_province_ids() # generate a string of provinces to prompt user with provinces_string = "\n" for province_no in provinces: provinces_string += str(province_no) + ": " + ( provinces[province_no] + "\n") # second arg is the province number province_num = input("Enter a province number from:" + provinces_string) # generate the kijiji url websiteObject = Url()
def handle_command(command, channel): """ Executes bot command if the command is known These are the available commands: peek <product> in <location> peek <product> in <location> saveas <db> locations help """ # Default response is help text for the user default_response = "Uknown command. Try *{}* for list of commands and usage.".format( "help") # Finds and executes the given command, filling in response response = None # get the location, locations and locaiton ids l = Locations() provinces = l.get_provinces() province_ids = l.get_province_ids() # locations if (command == "locations"): # print a message of the available locations provinces_string = "\n" for province_no in provinces: provinces_string += str( province_no) + ": " + provinces[province_no] + "\n" response = "Choose a locaton number from" + provinces_string # help elif (command == "help"): # print out all the usable commands response = "Here are list of commands to get you started." + ( "\n\n*{}* _product name_ *{}* _location number_".format( "peek", "in") ) + ("\nEXAMPLE: To get the lowest gtx 1070 in Ontario") + ( "\n peek gtx 1070 in 0" ) + ( "\n\n*{}* _product name_ *{}* _location number_ *{}* _database name_" .format("peek", "in", "saveas") ) + ( "\n EXAMPLE: Find cheapest scarlett 2i2 in BC put it in 'mytable.db'" ) + ("\n peek scarlett 2i2 in 2 saveas mytable") + ("\n\n*{}*".format( "locations")) + ("\n Lists all the location numbers") # peek <product name> in <location number>" # startswith peek # has " in " # product name = command[index(peek): index(in)] # location = command[index(in):] # remove beggining and end spaces from both elif (command.startswith("peek ") and " in " in command): peek_right_index = command.find("peek ") + len("peek ") in_left_index = command.find(" in ") in_right_index = command.find(" in ") + len(" in ") # product is between peek and in product = command[peek_right_index:in_left_index] # check if a valid location filter is used after_in = command[in_right_index:] #print (after_in) # if a valid location filter is used if (after_in.strip().isdigit()): province_num = int(after_in.strip()) website = url(product, province_num, provinces, province_ids) (product_name, product_price, link, date) = cheapest(website, product) response = "The cheapest " + product + " in " + provinces[ province_num] + (" is the \n" + "<{}|{}>".format(link, product_name) + "\n") + ("costing $" + str(product_price) + ", posted " + date) # check if the after_in is of the form <number> ... saveas <text> elif (" saveas " in after_in): saveas_left_index = after_in.find(" saveas ") saveas_right_index = after_in.find(" saveas ") + len(" saveas ") before_saveas = after_in[:saveas_left_index] # check if valid location is used if (after_in[:saveas_left_index].strip().isdigit()): # get the province num province_num = int(after_in[:saveas_left_index].strip()) website = url(product, province_num, provinces, province_ids) (product_name, product_price, link, date) = cheapest(website, product) table_name = after_in[saveas_right_index:] db(product_name, product_price, provinces[province_num], link, date, table_name) response = "Added cheapest " + product + " in " + ( provinces[province_num] ) + (" \n" + "<{}|{}>".format(link, product_name) + "\n") + ( "costing $" + str(product_price) + ", posted " + date + ("\nto the database named " + ("*{}*".format(table_name) + "!"))) # Sends the response back to the channel slack_client.api_call("chat.postMessage", channel=channel, text=response or default_response)
import re from Location import Location from Locations import Locations # Calculates moving average def movingAverage(avg, new_sample, n): avg -= avg / n avg += new_sample / n return avg if __name__ == "__main__": # Saves locations and cost information colLocations = Locations() try: myFile = open( 'C:\\Users\\josh.dombal\\PycharmProjects\\JobLocationFinder\\costOfLiving', mode='r') f = open('locationInfo.txt', 'w') count = 0 job1 = None # Runs through each line costOfLiving.txt and scrapes info about jobs for each location for line in myFile: count += 1 locat = Location() #print(line) new = [x.strip() for x in line.split(',')] #print(new)
def build(objtId, p): if (p.__class__.__name__ == 'AttackerParameters'): return Attacker(objtId, p.name(), p.description(), p.image(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'PersonaParameters'): return Persona(objtId, p.name(), p.activities(), p.attitudes(), p.aptitudes(), p.motivations(), p.skills(), p.intrinsic(), p.contextual(), p.image(), p.assumption(), p.type(), p.tags(), p.environmentProperties(), p.codes()) if (p.__class__.__name__ == 'AssetParameters'): return Asset(objtId, p.name(), p.shortCode(), p.description(), p.significance(), p.type(), p.critical(), p.criticalRationale(), p.tags(), p.interfaces(), p.environmentProperties()) if (p.__class__.__name__ == 'TemplateAssetParameters'): return TemplateAsset(objtId, p.name(), p.shortCode(), p.description(), p.significance(), p.type(), p.surfaceType(), p.accessRight(), p.properties(), p.rationale(), p.tags(), p.interfaces()) if (p.__class__.__name__ == 'TemplateRequirementParameters'): return TemplateRequirement(objtId, p.name(), p.asset(), p.type(), p.description(), p.rationale(), p.fitCriterion()) if (p.__class__.__name__ == 'TemplateGoalParameters'): return TemplateGoal(objtId, p.name(), p.definition(), p.rationale(), p.concerns(), p.responsibilities()) if (p.__class__.__name__ == 'SecurityPatternParameters'): return SecurityPattern(objtId, p.name(), p.context(), p.problem(), p.solution(), p.requirements(), p.associations()) if (p.__class__.__name__ == 'ComponentParameters'): return Component(objtId, p.name(), p.description(), p.interfaces(), p.structure(), p.requirements(), p.goals(), p.associations()) if (p.__class__.__name__ == 'ComponentViewParameters'): return ComponentView(objtId, p.name(), p.synopsis(), p.components(), p.connectors(), p.attackSurfaceMetric()) if (p.__class__.__name__ == 'ValueTypeParameters'): return ValueType(objtId, p.name(), p.description(), p.type(), p.score(), p.rationale()) if (p.__class__.__name__ == 'ClassAssociationParameters'): return ClassAssociation(objtId, p.environment(), p.headAsset(), p.headDimension(), p.headNavigation(), p.headType(), p.headMultiplicity(), p.headRole(), p.tailRole(), p.tailMultiplicity(), p.tailType(), p.tailNavigation(), p.tailDimension(), p.tailAsset(), p.rationale()) if (p.__class__.__name__ == 'GoalAssociationParameters'): return GoalAssociation(objtId, p.environment(), p.goal(), p.goalDimension(), p.type(), p.subGoal(), p.subGoalDimension(), p.alternative(), p.rationale()) if (p.__class__.__name__ == 'DependencyParameters'): return Dependency(objtId, p.environment(), p.depender(), p.dependee(), p.dependencyType(), p.dependency(), p.rationale()) if (p.__class__.__name__ == 'GoalParameters'): return Goal(objtId, p.name(), p.originator(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'ObstacleParameters'): return Obstacle(objtId, p.name(), p.originator(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'DomainPropertyParameters'): return DomainProperty(objtId, p.name(), p.description(), p.type(), p.originator(), p.tags()) if (p.__class__.__name__ == 'ThreatParameters'): return Threat(objtId, p.name(), p.type(), p.method(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'VulnerabilityParameters'): return Vulnerability(objtId, p.name(), p.description(), p.type(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'RiskParameters'): return Risk(objtId, p.name(), p.threat(), p.vulnerability(), p.tags(), p.misuseCase()) if (p.__class__.__name__ == 'ResponseParameters'): return Response(objtId, p.name(), p.risk(), p.tags(), p.environmentProperties(), p.responseType()) if (p.__class__.__name__ == 'CountermeasureParameters'): return Countermeasure(objtId, p.name(), p.description(), p.type(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'TaskParameters'): return Task(objtId, p.name(), p.shortCode(), p.objective(), p.assumption(), p.author(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'UseCaseParameters'): return UseCase(objtId, p.name(), p.author(), p.code(), p.actors(), p.description(), p.tags(), p.environmentProperties()) if (p.__class__.__name__ == 'MisuseCaseParameters'): return MisuseCase(objtId, p.name(), p.environmentProperties(), p.risk()) if (p.__class__.__name__ == 'DotTraceParameters'): return DotTrace(p.fromObject(), p.fromName(), p.toObject(), p.toName()) if (p.__class__.__name__ == 'EnvironmentParameters'): return Environment(objtId, p.name(), p.shortCode(), p.description(), p.environments(), p.duplicateProperty(), p.overridingEnvironment(), p.tensions()) if (p.__class__.__name__ == 'RoleParameters'): return Role(objtId, p.name(), p.type(), p.shortCode(), p.description(), p.environmentProperties()) if (p.__class__.__name__ == 'ResponsibilityParameters'): return Responsibility(objtId, p.name()) if (p.__class__.__name__ == 'ExternalDocumentParameters'): return ExternalDocument(objtId, p.name(), p.version(), p.date(), p.authors(), p.description()) if (p.__class__.__name__ == 'InternalDocumentParameters'): return InternalDocument(objtId, p.name(), p.description(), p.content(), p.codes(), p.memos()) if (p.__class__.__name__ == 'CodeParameters'): return Code(objtId, p.name(), p.type(), p.description(), p.inclusionCriteria(), p.example()) if (p.__class__.__name__ == 'MemoParameters'): return Memo(objtId, p.name(), p.description()) if (p.__class__.__name__ == 'DocumentReferenceParameters'): return DocumentReference(objtId, p.name(), p.document(), p.contributor(), p.description()) if (p.__class__.__name__ == 'ConceptReferenceParameters'): return ConceptReference(objtId, p.name(), p.dimension(), p.objectName(), p.description()) if (p.__class__.__name__ == 'PersonaCharacteristicParameters'): return PersonaCharacteristic(objtId, p.persona(), p.qualifier(), p.behaviouralVariable(), p.characteristic(), p.grounds(), p.warrant(), p.backing(), p.rebuttal()) if (p.__class__.__name__ == 'TaskCharacteristicParameters'): return TaskCharacteristic(objtId, p.task(), p.qualifier(), p.characteristic(), p.grounds(), p.warrant(), p.backing(), p.rebuttal()) if (p.__class__.__name__ == 'ImpliedProcessParameters'): return ImpliedProcess(objtId, p.name(), p.description(), p.persona(), p.network(), p.specification(), p.channels()) if (p.__class__.__name__ == 'LocationsParameters'): return Locations(objtId, p.name(), p.diagram(), p.locations(), p.links()) else: raise UnknownParameterClass(str(objtId))
def __init__(self, x_pos, y_pos): ''' Constructor ''' Locations.__init__(self,x_pos,y_pos)
class Simulator: photoVoltaics = PhotoVoltaics() comsumptions = Comsumptions() users = Users() locations = Locations() totalNoUsers = 10 # File Handle profileCSV = None def setup(self): print(Config.C_NORMAL+"Program Initialization...") # Load files self.loadFile() # Generate user data self.generateUsers() print("Initialization finished"+Config.C_VAUE+"=w="+Config.C_NORMAL) def loadFile(self): print("Load Location CSV files...") locationsCSV = Utils.loadCsv(Config.LOCATION_PROFILE_FILEPATH) print("Load Location CSV finished\nCreating location data...") for subtowm,latitude,longitude,dsp in zip(locationsCSV.neighbourhood,locationsCSV.latitude,locationsCSV.longitude,locationsCSV.DSP): self.locations.append(Location(latitude,longitude,subtowm,dsp)) print("Location load finish.") print("Load PV CSV files...") self.profileCSV = Utils.loadCsv(Config.PV_PROFILE_CSV_FILEPATH) # Create & Load PV data print("PV file load finished\nCreating PV data...") for date,production,time in zip(self.profileCSV.date,self.profileCSV.production,self.profileCSV.time): self.photoVoltaics.append(PhotoVoltaic(date,time,production)) # print(self.profileCSV.iloc[0,0]) # Create & Load Comsumption data print("Load Comsumptions file...") comsuptionsFileCount = 0 comsuptionsDataCount = 0 for filename in os.listdir(Config.CONSUMPTION_PROFILE_FILEPATH): file = Utils.loadCsv(Config.CONSUMPTION_PROFILE_FILEPATH+filename) print("Processing File:"+Config.C_VAUE+"{0}...".format(filename)+Config.C_NORMAL) comsumption = Comsumption([]) for i in range(0,Config.CONSUMPTION_COL): # Parse comsumption data for j in range(3,Config.CONSUMPTION_ROW): data = file.iloc[i,j] comsumption.appendComsumption(data) comsuptionsDataCount+=1 self.comsumptions.append(comsumption) comsuptionsFileCount+=1 # debug msg print("Comsumptions File load finish,total:{0}.".format(comsuptionsFileCount)) print("Comsumptions data created,total:{0}.".format(comsuptionsDataCount)) print("File loading process finish.") # Assigned random comsuption & generate amounts of user data """def generateUsers(self,amount): print("Generating {0} users data...".format(amount+1)) idx = 0 while idx < amount+1: self.users.append(self.generateUser(idx)) idx+=1 print("User data generation finished") """ def generateUsers(self): print("Please enter amount of user data wants to generated") numOfUser = input ("Numbers -> ") self.totalNoUsers = int(numOfUser) print("Please enter persentage of user have PVs") persentage = input ("Persentage -> ") persentageInUse = float(persentage)/float(100.00) idx = 0 while idx < int(self.totalNoUsers)+1: if(idx < int(self.totalNoUsers) * float(persentageInUse)): self.users.append(self.generateUser(idx,True)) idx+=1 else: self.users.append(self.generateUser(idx,False)) idx+=1 # Generating a user data def generateUser(self,userId,isHavePV): cFactor = random.gauss(Config.CMAXMEAN,Config.CMAXDEV) while (cFactor > Config.CMAXMAX or cFactor < Config.CMINMAX): cFactor = random.gauss(Config.CMAXMEAN,Config.CMAXDEV) # Calc PVFactor meanCapacityPV = (Config.MINCAPACITYPV + Config.MAXCAPACITYPV) / 2 devCapacityPV = (Config.MAXCAPACITYPV - meanCapacityPV) / 3 pvFactor = None pvFactor_t = random.gauss(meanCapacityPV,devCapacityPV) if(pvFactor_t < Config.MINCAPACITYPV): pvFactor = Config.MINCAPACITYPV elif(pvFactor_t > Config.MAXCAPACITYPV): pvFactor = Config.MAXCAPACITYPV else: pvFactor = pvFactor_t if(isHavePV == True): pv = self.photoVoltaics.getpvFactorizedPv(pvFactor) else: pv = self.photoVoltaics.getpvFactorizedPv(0) # print(pv[100].getProduction()) # randomly assign Location location = self.locations.random() # new user object comsumption = self.comsumptions.random() user = User(userId,pvFactor,cFactor,pv,comsumption,location) # debug # print(comsumption.getComsumptions()[0]) # print(len(user.getComsumptions())) return user # generate PV graph for a user def generateUserGraph(self,id,start_index,end_index): # id = 0 user = self.users.getUser(id) pvs = user.getPv() comsumptions = user.getComsumptions() x = [] y = [] y2 = [] y3 = [] # time = [] for i in range(start_index,end_index): #time.append(pvs[i].getTime()) # date = pvs[i].getDate() production = pvs[i].getProduction() x.append(i) y.append(production) comsuption = comsumptions[i] y2.append(comsuption) feedin = user.getFeedin(pvs[i],comsuption) y3.append(feedin) chart.plot(x,y,color='blue') chart.plot(x,y2,color='red') chart.plot(x,y3,color='green') chart.xlabel("Time/15 Min") chart.ylabel("production PV(blue)comsuption(red)feedin(green)") chart.title('Userid: {0}'.format(id)) # chart.xticks(x,time) chart.show() self.menu() # Generate Comsumption data for a user #def generateUserComsumption(self,start_index,end_index): # id = 0 # user = self.users.getUser(id) # comsumptions = user.getComsumptions() # x = [] # y = [] # # time = [] # for i in range(start_index,end_index): # #time.append(pvs[i].getTime()) # # date = pvs[i].getDate() # comsuption = comsumptions[i] # x.append(i) # y.append(comsuption) # # chart.plot(x,y) # chart.xlabel("Time/15 Min") # chart.ylabel("comsuption C") # # chart.xticks(x,time) # chart.show() def debugPurchesAndFeedin(self): id = 0 time = 5 user = self.users.getUser(id) pv = user.getPvByIndex(time) c = user.getComsumptionByIndex(time) price = user.getPrice(time) feedIn = user.getFeedin(pv,c) purches = user.getPurchase(pv,c) print("Price: {0} Feedin: {1} purches: {2}".format(price,feedIn,purches)) # debug pv def debugPV(self): print(self.photoVoltaics) def generateCSVRefenceFile(self): FileCSV.overwriteCsv() for i in range(0,35040): if(i%2 == 0): for j in range(1,self.totalNoUsers): print("time idx = {0}".format(i)) user = self.users.getUser(j) FileCSV.csv_feedin_purchase_1(user, i) # Packet.sendPacketHistory(user,timeIdx) def sendPacketByUserId(self,userId,timeIdx): print("time idx = {0}".format(timeIdx)) user = self.users.getUser(userId) Packet.sendPacketHistory(user,timeIdx) # Send user data (ordered) def sendPacket(self): Packet.printServerInfo() for i in range(0,35040): for j in range(1,self.totalNoUsers): self.sendPacketByUserId(j,i) # Send user data (un ordered) by time intergral # note the intergrals is minutes, default is 15 def sendPacketByInterval(self,minutesIntergral): Packet.printServerInfo() generatedIdx = [] # mins = datetime.datetime.now().strftime('%M') while True: minutes = datetime.datetime.now().strftime('%M') #second = datetime.datetime.now().strftime('%S') if int(minutes) % minutesIntergral == 0: #if int(second) % minutesIntergral == 0: for i in range(1,self.totalNoUsers): print(i) idx = random.choice(range(1,self.totalNoUsers)) while idx in generatedIdx: idx = random.choice(range(1,self.totalNoUsers)) generatedIdx.append(idx) self.sendPacketByUserId(idx, Utils.currentTimeToTimeIdx()) generatedIdx.clear() time.sleep(60) # Send user data (un ordered) def sendPacketRamble(self): Packet.printServerInfo() generatedIdx = [] for i in range(0,35040): if i == 35049: i = 0 for j in range(1,self.totalNoUsers): idx = random.choice(range(1,self.totalNoUsers)) while idx in generatedIdx: idx = random.choice(range(1,self.totalNoUsers)) #print("user id {0}".format(idx)) self.sendPacketByUserId(idx,Utils.currentTimeToTimeIdx()) # Fix problem that i forgot to add current idx into the list. generatedIdx.append(idx) #time.sleep(0.1) generatedIdx.clear() def menu(self): mode = '0' while mode == '0': print("=====================") print("Simulator Program") print("HOST: " + Config.C_VAUE + "{0}".format(Config.HOST_ADDR) + Config.C_NORMAL) print("PORT: " + Config.C_VAUE + "{0}".format(Config.HOST_PORT) + Config.C_NORMAL) print("CLIENT_NAME: " + Config.C_VAUE + "{0}".format(Config.HOST_CLIENT) + Config.C_NORMAL) print("=====================") print("1.Send data by sequence (Ordered)") print("2.Send data by unsequenced (Un Ordered)") print("3.Send data by interval (15 Mins)") print("4.Display data chart") print("5.Generate CSV File") print("6.Exit Program") mode = input ("Selection -> ") if(mode == '1'): self.sendPacket() elif(mode == '2'): self.sendPacketRamble() elif(mode == '3'): minutes = 15 self.sendPacketByInterval(minutes) elif(mode == '4'): userId = input ("Which user ? (please enter id) ->") timeIntergralstart = input ("time intergral start ? (please enter as interger number) ->") timeIntergralend = input ("time intergral end ? (please enter as interger number) ->") self.generateUserGraph(int(userId),int(timeIntergralstart),int(timeIntergralend)) #self.generateUserComsumption(int(userId),int(timeIntergral)) elif(mode == '5'): self.generateCSVRefenceFile() elif(mode == '6'): sys.exit() return else: print("Sorry, invaild option.") self.menu() def __init__(self): try: self.setup() # Graph #self.generateUserGraph(0,96) #self.generateUserComsumption(0,96) #self.debugPurchesAndFeedin() # Send data #self.sendPacket() #self.sendPacketByInterval(15) # Main Menu self.menu() except Exception as e: print("Sorry, an error has occur :( \n"+Config.C_VAUE+"{0}".format(e)) self.menu()
os._exit(0) else: # parent process for i in xrange( starttimeout ): sleep( 1 ) try: sendCommand( self.partition, "" ) except: continue else: break else: raise Exception("Correlator did not start.") # inject the parset self.parset.setFilename( Locations.resolvePath( "%s/RTCP-${OBSID}.parset" % (self.logdir,), self.parset ) ); info( "Sending parset '%s' to correlator." % (self.parset.filename,) ) self.parset.save() sendCommand( self.partition, "parset %s" % (self.parset.filename,) ) # quit immediately after processing the parset sendCommand( self.partition, "quit" ) # wait for correlator to finish def isStopped(): ret = os.waitpid( pid, os.WNOHANG ) if ret[1] > 0: raise Exception("Correlator did not start.") return ret != (0,0)