def keepAvahiBrowsing(thread_name, ipaddresses, lock, option):
    print("start keepAvahiBrowsing: threadname=" + thread_name + " option=" + option)
    while( True ):
        (output, err) = runShellCommand("avahi-browse -rtp _coap._udp | grep 'piSenseHat-4'")
        if( (err == None) or (output == None or len(output) == 0) ):
            print("SpotFinderThread: error avahi-browse err=" + str(err) + ",out=" + output)
        else:
            lines = output.splitlines()
            for line in lines:
                arr = line.split(";")
                if( len(arr) >= 8 ):
                    ip = arr[7]
                    #print("SpotFinderThread: testing ip=" + ip + ",isValidIp=" + str(isValidIpv4(ip)) + ",in=" + str(ip in ipaddresses))
                    lock.acquire()
                    if( isValidIpv4(ip) and (ip in ipaddresses) == False ):
                        print("SpotFinderThread: client-ip found ip=" + ip)
                        b = False
                        if(option == "skip"):
                            b = True
                        else:
                             b = sendServerIPtoParkingSpot("sendServerIPtoParkingSpot", ip, getOwnIP())
                        if( b == True ):
                            RequestUtils.createParkingSpot(ip)
                            ipaddresses.append(ip)
                    lock.release()
        time.sleep(5)
def init(p_ownIP, option):
    global re_ip
    global ownIP
    global ipaddresses

    ownIP = p_ownIP
    ipaddresses = []
    re_ip = re.compile('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$')
    RequestUtils.clearDB()
    thread.start_new_thread(keepAvahiBrowsing, ("SpotFinderThread,keepAvahiBrowsing", ipaddresses, lock, option))
    thread.start_new_thread(keepReadingJoystickFiles, ("SpotFinderThread,keepReadingJoystickFiles", ipaddresses, lock))
 def validate_service(current_item):
     """
     Validate a single service
     :param current_item: Input item/service
     :return: Dictionary of results
     """
     item_id = current_item[0]
     item_content = current_item[1]
     item = item_content['agolItem']
     type_keywords = item['typeKeywords']
     require_token = _requires_token("Requires Subscription", type_keywords)
     print(f"{item_id}\t{item_content['title']}")
     print(f"default retry count threshold: {item_content['default_retry_count']}")
     print(f"default timeout threshold: {item_content['default_timeout']}")
     print(f"service url: {item_content['service_url']}")
     print(f"requires token: {require_token}")
     response = RequestUtils.check_request(path=item_content["service_url"],
                                           params={},
                                           try_json=True,
                                           add_token=require_token,
                                           retry_factor=item_content["default_retry_count"],
                                           timeout_factor=item_content["default_timeout"],
                                           token=item_content["token"],
                                           id=item_id)
     print("\n")
     return current_item[0], {
         **current_item[1],
         **{"serviceResponse": response}
     }
 def getCvImageAndUrl(self, index, useThumbnail=False):
     if index >= self._numResultsReceived:
         return None, None
     result = self._results[index]
     if useThumbnail:
         url = result.thumbnail_url
     else:
         url = result.content_url
     return RequestUtils.cvImageFromUrl(url), url
def keepReadingJoystickFiles(thread_name, ipaddresses, lock):
    # reads the joystickfiles jsUpdate-<end_point>.txt that are output by Java
    # assumes these are in the directory below
    print("start keepReadingJoystickFiles thread_name=" + thread_name);
    path = os.path.realpath(__file__)
    path = path[0:path.rindex("/")]
    path = path[0:path.rindex("/")+1] # get parent directory
    prefix = "jsUpdate-"
    suffix = ".txt"
    print("keepReadingJoystickFiles path=" + path)

    while( True ):
        fileNames = os.listdir(path)
        for fileName in fileNames:
            if prefix in fileName:
                endpoint = fileName[len(prefix):len(fileName)-len(suffix)]
                print("keepReadingJoystickFiles fileName=" + fileName, "endpoint=" + endpoint)
                RequestUtils.enterOrLeaveVehicle(endpoint)
                # delete file
                os.remove(fileName)
        time.sleep(1)
 def handle_mobile_request(self, request):
     logging.info("Mobile request -> " + request)
     parser = RequestUtils.validate(request)
     if len(parser) == 3:
         try :
             request_code = int(parser[0])
             self.send_mob_response(request_code, parser[1], parser[2])
         except :
             self.handle_exception()
             self.send_resp("640 <Invalid request format>##" \
                                     + parser[2] + "##")
     else :
         self.send_resp("640 <Invalid request format>####")
		def testValidator(self):
			self.assertEqual(RequestUtils.validate( \
							""), [])
			self.assertEqual(RequestUtils.validate( \
							"<>####"), [])
			self.assertEqual(RequestUtils.validate( \
							"600 <>####"), [])
			self.assertEqual(RequestUtils.validate( \
							"600 <>##ROUTER=OPX##"), ['600','','ROUTER=OPX'])
			self.assertEqual(RequestUtils.validate( \
							"800 app_id=?>##ROUTER=OPX##"), [])
			self.assertEqual(RequestUtils.validate( \
							"800 <app_id=?##ROUTER=OPX##"), [])
			self.assertEqual(RequestUtils.validate( \
							"800 <app_id=?>ROUTER=OPX##"), [])
			self.assertEqual(RequestUtils.validate( \
							"800 <app_id=?>##ROUTER=OPX"), [])
			self.assertEqual(RequestUtils.validate( \
							"800 <app_id=?>##ROUTER=OPX##"), \
							['800','app_id=?','ROUTER=OPX'])
        def create_response(self, response, request_echo_params):
            parser = RequestUtils.validate(response)
            #merging the echo_params
            response = parser[0] + " <" + parser[1] + ">"
            response += "##" + request_echo_params + "##";
	    response = response.replace("<<","<").replace(">>",">");
            if len(parser) == 3 and parser[2] != '':
                response += "," + parser[2]
                parsed_echo_params = Parser.parse_echo_params(parser[2])
                if parsed_echo_params.has_key('TEST_TIMEOUT'):
                    time_out = int(parsed_echo_params['TEST_TIMEOUT'])
                    time.sleep(time_out)

            response += "##"

            return response
 def check_layer_url(layer=None) -> dict:
     """ Check that the Item's url is valid """
     if layer is None:
         layer = {}
     response = {
         "id": layer["id"],
         "success": False
     }
     if layer["success"]:
         url = layer["url"]
         response = RequestUtils.check_request(path=url,
                                               params=layer['params'],
                                               try_json=layer['try_json'],
                                               add_token=layer['add_token'],
                                               retry_factor=layer['retryCount'],
                                               timeout_factor=layer['timeout'],
                                               id=layer["id"],
                                               token=layer['token'])
     return response
def check_alfp_url(input_data=None) -> dict:
    """

    :param input_data:
    :return:
    """
    if input_data is None:
        input_data = {}
    response = RequestUtils.check_request(path=input_data["url"],
                                          params=input_data['params'],
                                          try_json=input_data['try_json'],
                                          add_token=input_data['add_token'],
                                          retry_factor=input_data['retry_factor'],
                                          timeout_factor=input_data['timeout_factor'],
                                          token=input_data['token'],
                                          id=input_data["id"])
    return {
        "id": input_data["id"],
        "response": response
    }
        def create_802_response(self, params, echo_params):
            params = Parser.parse_800_params(params)
            if len(params) == 0: return ["", "640 <Invalid Request>"]

            echo_params = Parser.parse_echo_params(echo_params)
            if not echo_params.has_key('ROUTER'):
                return ["", "640 <No Router>"]
        
            app_id = ""    
            if params.has_key('APP_ID'):

                app_id = params['APP_ID']
                if app_id == '?' or not devices.has_key(app_id):
                    app_id = RequestUtils.generateAppId()
                    self.addDeviceData(app_id, params, echo_params)

                response = "802 <APP_ID=" + app_id + ">"
            else :
                response = "640 <No app_id in the request>"

	    response = response.replace("####", "##");
            return [app_id, response]
parsed['postAdForm.mapRadius'] = ['75.29440284317512']
parsed['postAdForm.adType'] = ['OFFER']
parsed['postAdForm.priceType'] = ['FIXED']
parsed['postAdForm.priceAmount'] = ['1000']
parsed['postAdForm.attributeMap[forsaleby_s]'] = ['ownr']
parsed['postAdForm.title'] = ['asdfasdff']
parsed['postAdForm.description'] = ['asdfasdfasdfasdf']
# parsed['file']=['']
# parsed['postAdForm.youtubeVideoURL']=['']
# parsed['location-fallback']=['k1m 0s6']
# parsed['postAdForm.phoneNumber']=['']
parsed['featuresForm.topAdDuration'] = ['7']
# parsed['submitType']=['saveAndCheckout']

session = login.new_session()
sessionStr = RequestUtils.get_session_str(session)
client = httpclient.AsyncHTTPClient()
httpmethod = "POST"
url = "https://www.kijiji.ca/p-submit-ad.html"
nativeCookies = {
    'Content-Type': 'application/x-www-form-urlencoded',
    "Cookie": sessionStr
}

necessary = []
toCheck = len(parsed.keys())


def handle_create(field, isNec):
    print("Failed field is :", field)
    necessary.append(field)
import PostAdAsync
import RequestUtils
import delete_ad

from tornado import ioloop, httpclient

# with open('./data/failed-creates.json', 'r') as f:
#     with open('./data/all-categories-flat.json', 'r') as flatFile:
#         sess = RequestUtils.get_session()
#         allData = json.load(flatFile)
#         data = json.load(f)
#         for d in data:
#             PostAdAsync.get_ad(d, sess)
#         ioloop.IOLoop.instance().start()
#         delete_ad.delete_all()

# newFailed = copy.copy(PostAdAsync.failed)
# PostAdAsync.failed = []
        
sessionStr = RequestUtils.get_session()
failed = [12, 646, 772, 776, 773, 782, 760]
with open('./data/failed-data-fields.json', 'r') as failedFieldFile:
    failedFields = json.load(failedFieldFile)
    for d in failed:
        PostAdAsync.get_ad(d, sessionStr, None)
ioloop.IOLoop.instance().start()
# with open('./data/all-categories-flat.json', 'r') as flatFile:
#     allData = json.load(flatFile)
#     for d in failed:
#         print(allData[str(d)])
Exemple #14
0
    request = httpclient.HTTPRequest(url,
                                     method=httpmethod,
                                     headers=nativeCookies)
    client.fetch(
        request,
        partial(handle_getad, categoryId, sessionStr, extraFields, finalCb))


def Create_Callbacks():
    cbs = {}
    cbs['OnSuccessCreate'] = handle_success_create
    cbs['OnFailCreate'] = handle_failed_create
    return cbs


def main(session, toTest):
    for c in toTest:
        get_ad(c, session, None, handle_delete)


if __name__ == '__main__':
    catId = 10
    children = KijijiCategories.load_child_flat(catId)

    session = login.new_session()
    cookiesStr = RequestUtils.get_session_str(session)
    main(cookiesStr, toTest)
    ioloop.IOLoop.instance().start()
    with open('./data/failed-creates.json', 'w') as f:
        dump(failed, f)
def get_beautiful_soup(url):
    print url
    request = RequestUtils.get_request(url)
    soup = BeautifulSoup(request.content.decode('utf-8', 'ignore'), 'lxml')
    return soup