def post2fmpi(self): # connection paramter to FMPI url = self.company_id.api_host.strip() db = self.company_id.fmpi_pgn username = self.company_id.api_user password = self.company_id.api_pass # attempt to connect logger.info("Connecting to " + url) common = xmlrpclib.ServerProxy('{}/xmlrpc/2/common'.format(url)) uid = common.authenticate(db, username, password, {}) if not uid: raise exceptions.except_orm( _('Remote Authentication Failed'), _(url + " failed to authenticate " + username)) return models = xmlrpclib.ServerProxy('{}/xmlrpc/2/object'.format(url)) if not models: raise exceptions.except_orm( _('Models: Remote Authentication Failed'), _(url + " failed to authenticate " + username)) return # sync from dealer-to-fmpi fmpi = self.env['fmpi.service.history'].search([('fmpi_history_id', '=', False)]) if fmpi: for line in fmpi: logger.info("Posting ID#" + str(line.id)) id = models.execute_kw( db, uid, password, 'fmpi.service.history', 'create', [{ 'dealer_id': line.dealer_id.id, 'name': line.name, 'parts_and_jobs': line.parts_and_jobs, 'customer_name': line.customer_name, 'charged_to': line.charged_to, 'run_km': line.run_km, 'one_fu_id': line.one_fu_id.id, 'confirmation_date': line.confirmation_date }]) if not id: raise exceptions.except_orm( _('Failed to post to FMPI'), _("Posting of transaction to FMPI has failed")) return line.write({'fmpi_history_id': id}) # sync from fmpi-to-dealer # d_ids = fmpi.search([('fmpi_history_id','!=',False)]) # if d_ids: # aID = [] # for d_id in d_ids: # aID.append(d_id.fmpi_history_id) # f_ids = models.execute_kw(db, uid, password, 'fmpi.service.history', 'search', # [[['id','not in',aID]]]) # [record] = models.execute_kw(db, uid, password, 'fmpi.service.history', 'read', [f_ids]) # if record: # for newH in record: # fmpi.create({ # 'dealer_id': newH.dealer_id, # 'name': newH.name, # 'parts_and_jobs': newH.parts_and_jobs, # 'customer_name': newH.customer_name, # 'charged_to': newH.charged_to, # 'run_km': newH.run_km, # 'one_fu_id': newH.one_fu_id, # 'confirmation_date': newH.confirmation_date, # 'fmpi_history_id': newH.id}) return
def test_path3(self): p = xmlrpclib.ServerProxy(URL + "/is/broken") self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
def test_transport(self): t = xmlrpclib.Transport() p = xmlrpclib.ServerProxy(self.url, transport=t) self.assertEqual(p('transport'), t)
def test_allow_dotted_names_true(self): # XXX also need allow_dotted_names_false test. server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT)) data = server.Fixture.getData() self.assertEqual(data, '42')
def test_path1(self): p = xmlrpclib.ServerProxy(URL + "/foo") self.assertEqual(p.pow(6, 8), 6**8) self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
def schedule_backup(self): conf_ids = self.search([]) for rec in conf_ids: db_list = self.get_db_list(rec.host, rec.port) if rec.name in db_list: try: if not os.path.isdir(rec.folder): os.makedirs(rec.folder) except: raise # Create name for dumpfile. bkp_file = '%s_%s.%s' % (time.strftime('%Y_%m_%d_%H_%M_%S'), rec.name, rec.backup_type) file_path = os.path.join(rec.folder, bkp_file) uri = 'http://' + rec.host + ':' + rec.port conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/db') bkp = '' try: # try to backup database and write it away fp = open(file_path, 'wb') odoo.service.db.dump_db(rec.name, fp, rec.backup_type) fp.close() except Exception as error: _logger.debug( "Couldn't backup database %s. Bad database administrator password for server running at http://%s:%s" % (rec.name, rec.host, rec.port)) _logger.debug("Exact error from the exception: " + str(error)) continue else: _logger.debug("database %s doesn't exist on http://%s:%s" % (rec.name, rec.host, rec.port)) # Check if user wants to write to SFTP or not. if rec.sftp_write is True: try: # Store all values in variables dir = rec.folder pathToWriteTo = rec.sftp_path ipHost = rec.sftp_host portHost = rec.sftp_port usernameLogin = rec.sftp_user passwordLogin = rec.sftp_password _logger.debug('sftp remote path: %s' % pathToWriteTo) try: s = paramiko.SSHClient() s.set_missing_host_key_policy(paramiko.AutoAddPolicy()) s.connect(ipHost, portHost, usernameLogin, passwordLogin, timeout=20) sftp = s.open_sftp() except Exception as error: _logger.critical( 'Error connecting to remote server! Error: ' + str(error)) try: sftp.chdir(pathToWriteTo) except IOError: # Create directory and subdirs if they do not exist. currentDir = '' for dirElement in pathToWriteTo.split('/'): currentDir += dirElement + '/' try: sftp.chdir(currentDir) except: _logger.info( '(Part of the) path didn\'t exist. Creating it now at ' + currentDir) # Make directory and then navigate into it sftp.mkdir(currentDir, 777) sftp.chdir(currentDir) pass sftp.chdir(pathToWriteTo) # Loop over all files in the directory. for f in os.listdir(dir): if rec.name in f: fullpath = os.path.join(dir, f) if os.path.isfile(fullpath): try: sftp.stat(os.path.join(pathToWriteTo, f)) _logger.debug( 'File %s already exists on the remote FTP Server ------ skipped' % fullpath) # This means the file does not exist (remote) yet! except IOError: try: # sftp.put(fullpath, pathToWriteTo) sftp.put( fullpath, os.path.join(pathToWriteTo, f)) _logger.info( 'Copying File % s------ success' % fullpath) except Exception as err: _logger.critical( 'We couldn\'t write the file to the remote server. Error: ' + str(err)) # Navigate in to the correct folder. sftp.chdir(pathToWriteTo) # Loop over all files in the directory from the back-ups. # We will check the creation date of every back-up. for file in sftp.listdir(pathToWriteTo): if rec.name in file: # Get the full path fullpath = os.path.join(pathToWriteTo, file) # Get the timestamp from the file on the external server timestamp = sftp.stat(fullpath).st_atime createtime = datetime.datetime.fromtimestamp( timestamp) now = datetime.datetime.now() delta = now - createtime # If the file is older than the days_to_keep_sftp (the days to keep that the user filled in on the Odoo form it will be removed. if delta.days >= rec.days_to_keep_sftp: # Only delete files, no directories! if sftp.isfile(fullpath) and ( ".dump" in file or '.zip' in file): _logger.info( "Delete too old file from SFTP servers: " + file) sftp.unlink(file) # Close the SFTP session. sftp.close() except Exception as e: _logger.debug( 'Exception! We couldn\'t back up to the FTP server..') # At this point the SFTP backup failed. We will now check if the user wants # an e-mail notification about this. if rec.send_mail_sftp_fail: try: ir_mail_server = self.env['ir.mail_server'] message = "Dear,\n\nThe backup for the server " + rec.host + " (IP: " + rec.sftp_host + ") failed.Please check the following details:\n\nIP address SFTP server: " + rec.sftp_host + "\nUsername: "******"\nPassword: "******"\n\nError details: " + tools.ustr( e) + "\n\nWith kind regards" msg = ir_mail_server.build_email( "auto_backup@" + rec.name + ".com", [rec.email_to_notify], "Backup from " + rec.host + "(" + rec.sftp_host + ") failed", message) ir_mail_server.send_email(self._cr, self._uid, msg) except Exception: pass """ Remove all old files (on local server) in case this is configured.. """ if rec.autoremove: dir = rec.folder # Loop over all files in the directory. for f in os.listdir(dir): fullpath = os.path.join(dir, f) # Only delete the ones wich are from the current database # (Makes it possible to save different databases in the same folder) if rec.name in fullpath: timestamp = os.stat(fullpath).st_ctime createtime = datetime.datetime.fromtimestamp(timestamp) now = datetime.datetime.now() delta = now - createtime if delta.days >= rec.days_to_keep: # Only delete files (which are .dump and .zip), no directories. if os.path.isfile(fullpath) and (".dump" in f or '.zip' in f): _logger.info( "Delete local out-of-date file: " + fullpath) os.remove(fullpath)
def rpc() -> client.ServerProxy: return client.ServerProxy( "http://localhost", transport=UnixStreamTransport("/var/run/supervisor.sock"))
def connect(self): if not self.use_rest and not self.use_xmlrpc: raise ConfluenceConfigurationError( """Both REST and XML-RPC """ """options have been explicitly disabled. Unable to publish.""" ) if self.use_rest: self.rest_client = Rest(self.config) try: rsp = self.rest_client.get('space', { 'spaceKey': self.space_name, 'limit': 1 }) if rsp['size'] == 0: raise ConfluenceBadSpaceError(self.space_name) self.space_display_name = rsp['results'][0]['name'] self.use_xmlrpc = False except ConfluenceBadApiError: if not self.use_xmlrpc: raise self.use_rest = False except ConfluenceBadServerUrlError: if not self.use_xmlrpc: raise self.use_rest = False if self.use_xmlrpc: try: transport = None if self.proxy or self.timeout: transport = ConfluenceTransport() if self.proxy: transport.set_proxy(self.proxy) if self.timeout: transport.set_timeout(self.timeout) self.xmlrpc = xmlrpclib.ServerProxy(self.server_url + '/rpc/xmlrpc', transport=transport, allow_none=True) except IOError as ex: raise ConfluenceBadServerUrlError(self.server_url, ex) if self.server_user: try: token = self.xmlrpc.confluence1.login( self.server_user, self.server_pass) try: self.token = self.xmlrpc.confluence2.login( self.server_user, self.server_pass) self.xmlrpc.confluence1.logout(token) self.xmlrpc = self.xmlrpc.confluence2 except xmlrpclib.Error: self.token = None except xmlrpclib.ProtocolError as ex: if ex.errcode == 403: raise ConfluenceRemoteApiDisabledError(self.server_url) raise ConfluenceBadServerUrlError(self.server_url, ex) except (httplib.InvalidURL, socket.error) as ex: raise ConfluenceBadServerUrlError(self.server_url, ex) except xmlrpclib.Fault as ex: if ex.faultString.find('AuthenticationFailed') != -1: raise ConfluenceAuthenticationFailedUrlError raise if not self.token: raise ConfluenceLegacyError else: self.token = '' # Anonymous. if self.token: try: self.xmlrpc.getSpace(self.token, self.space_name) except xmlrpclib.Fault as ex: self.xmlrpc.logout(self.token) raise ConfluenceBadSpaceError(self.space_name) else: try: self.xmlrpc.confluence2.getSpace(None, self.space_name) self.xmlrpc = self.xmlrpc.confluence2 except xmlrpclib.Fault as ex: try: self.xmlrpc.confluence1.getSpace(None, self.space_name) self.xmlrpc = self.xmlrpc.confluence1 except xmlrpclib.Fault as ex: raise ConfluenceBadSpaceError(self.space_name)
from xmlrpc import client # The common XML.RPC endpoint srv = "http://localhost:8069" common = client.ServerProxy("%s/xmlrpc/2/common" % srv) common.version() # Result: {'server_version': '14.0', 'server_version_info': [14, 0, 0, 'final', 0, ''], 'server_serie': '14.0', 'protocol_version': 1} db, user, password = "******", "admin", "admin" uid = common.authenticate(db, user, password, {}) print(uid) # The object XML-RPC endpoint api = client.ServerProxy('%s/xmlrpc/2/object' % srv) api.execute_kw(db, uid, password, "res.users", "search_count", [[]]) api.execute_kw(db, uid, password, "res.users", "read", [2, ["login", "name", "company_id"]]) # Result: [{'id': 2, 'login': '******', 'name': 'Mitchell Admin', 'company_id': [1, 'YourCompany']}] domain = [("login", "=", "admin")] api.execute_kw(db, uid, password, "res.users", "search", [domain]) # Result : [2] api.execute_kw(db, uid, password, "res.users", "search_read", [domain, ["login", "name"]]) # Result: [{'id': 2, 'login': '******', 'name': 'Mitchell Admin'}] # Same call, using keyword arguments instead of positional arguments
def action_submit_api(self): # 1. make connection to FMPI dealer_id = self.company_id.dealer_id.id # FMPI's API Connection Parameters url = self.company_id.fmpi_host.strip() db = self.company_id.fmpi_pgn username = self.company_id.fmpi_pgu password = self.company_id.fmpi_pgp vqir_number = self.name # connect to FMPI logger.info("Connecting to " + url) common = xmlrpclib.ServerProxy('{}/xmlrpc/2/common'.format(url)) uid = common.authenticate(db, username, password, {}) if not uid: raise exceptions.except_orm(_('Remote Authentication Failed'), _(url + " failed to authenticate " + username)) return models = xmlrpclib.ServerProxy('{}/xmlrpc/2/object'.format(url)) cur_stamp = fields.datetime.now() # Query existence of dealer's VQIR from FMPI Database fmpi_existing_vqir = models.execute_kw(db, uid, password, 'fmpi.vqir', 'search', [[['name', '=', vqir_number], ['dealer_id', '=', dealer_id], ['vqir_date', '=', self.vqir_date]]]) if fmpi_existing_vqir: vqir_state_logs = "Document:" + (self.name or 'Empty Document') + "\n" + \ "Re-submitted by: " + (self.env.user.name or 'No User Name specified') + "\n" + \ "Re-submitted at: " + datetime.datetime.now().strftime("%m/%d/%Y") + "\n" + \ "--------------------------------------------------\n" self.write({'vqir_state': 'submit', 'vqir_state_logs': vqir_state_logs + str(self.vqir_state_logs or ''), "submitted_date":cur_stamp}) for existingID in fmpi_existing_vqir: fmpi_vqir_id = models.execute_kw(db, uid, password, 'fmpi.vqir', 'write', [[existingID], { 'vqir_state': 'submit', 'date_occur': self.date_occur, 'vqir_type': self.vqir_type, 'vqir_city': self.vqir_city, 'place_of_incident': self.place_of_incident, 'km_1st_trouble': self.km_1st_trouble, 'run_km': self.run_km, 'person': self.person, 'others': self.others, 'trouble_explanation': self.trouble_explanation, 'trouble_cause_analysis': self.trouble_cause_analysis, 'disposal_measures': self.disposal_measures, 'proposal_for_improvement': self.proposal_for_improvement, 'driver_name': self.driver_name, 'ss_name': self.ss_name, 'ss_street1': self.ss_street1, 'ss_street2': self.ss_street2, 'ss_city': self.ss_city, 'ss_phone': self.ss_phone, 'ss_mobile': self.ss_mobile, 'ss_fax': self.ss_fax, 'ss_email': self.ss_email, 'users_name': self.users_name, 'users_street1': self.users_street1, 'users_street2': self.users_street2, 'users_city': self.users_city, 'users_phone': self.users_phone, 'users_mobile': self.users_mobile, 'users_fax': self.users_fax, 'users_email': self.users_email, 'reps_name': self.reps_name, 'reps_street1': self.reps_street1, 'reps_street2': self.reps_street2, 'reps_city': self.reps_city, 'reps_phone': self.reps_phone, 'reps_mobile': self.reps_mobile, 'reps_fax': self.reps_fax, 'reps_email': self.reps_email, 'remarks': self.remarks, 'fos_fu_id': self.fos_fu_id.id, 'vqir_state_logs': self.vqir_state_logs, 'submitted_date': fields.datetime.now(), 'declined_date': self.declined_date, 'disapproved_date': self.disapproved_date, 'ack_date': self.ack_date, 'paid_date': self.paid_date, 'url': self.company_id.dealer_host.strip(), 'db' : self.company_id.dealer_pgn, 'username' : self.company_id.dealer_pgu, 'password' : self.company_id.dealer_pgp}]) # query IDs of parts and jobs from FMPI Database fmpi_existing_vqir_pj_ids = models.execute_kw(db, uid, password, 'fmpi.vqir.parts.and.jobs', 'search', [[['fmpi_vqir_id', '=', existingID]]]) # delete parts and jobs from FMPI Database models.execute_kw(db, uid, password, 'fmpi.vqir.parts.and.jobs', 'unlink', [fmpi_existing_vqir_pj_ids]) # re-create parts and jobs record based on Dealer's Database for ji in self.fos_vqir_parts_and_jobs_line: models.execute_kw(db, uid, password, 'fmpi.vqir.parts.and.jobs', 'create', [{ 'name': ji.name, 'fmpi_vqir_id': existingID, 'si_number':ji.si_number, 'si_date':ji.si_date, 'parts_number': ji.part_id.name, 'parts_desc': ji.parts_desc, 'parts_qty': ji.parts_qty, 'parts_cost': ji.parts_cost, 'parts_with_fee': ji.parts_with_fee, 'parts_total': ji.parts_total, 'job_code': ji.job_code, 'job_code_desc': ji.job_code_desc, 'job_qty': ji.job_qty, 'job_cost': ji.job_cost, 'dealer_pj_id': ji.id }]) # query IDs of VQIR Images from FMPI Database fmpi_existing_vqir_images_ids = models.execute_kw(db, uid, password, 'fmpi.vqir.images', 'search', [[['fmpi_vqir_id', '=', existingID]]]) # delete VQIR Images from FMPI Database models.execute_kw(db, uid, password, 'fmpi.vqir.images', 'unlink', [fmpi_existing_vqir_images_ids]) # re-create VQIR Images record based on Dealer's Database for img in self.fos_vqir_images_line: models.execute_kw(db, uid, password, 'fmpi.vqir.images', 'create', [{ 'name': img.name, 'fmpi_vqir_id': existingID, 'image': img.image, 'image_medium': img.image_medium, 'image_small': img.image_small, 'image_remarks': img.image_remarks, }]) else: # 2. call fmpi.vqir model vqir_state_logs = "Document:" + (self.name or 'Empty Document') + "\n" + \ "Submitted by: " + (self.env.user.name or 'No User Name specified') + "\n" + \ "Submitted at: " + datetime.datetime.now().strftime("%m/%d/%Y") + "\n" + \ "--------------------------------------------------\n" self.write({'vqir_state': 'submit', 'vqir_state_logs': vqir_state_logs + str(self.vqir_state_logs or ''), "submitted_date":cur_stamp}) fmpi_vqir_id = models.execute_kw(db, uid, password, 'fmpi.vqir', 'create', [{ 'dealer_id': self.company_id.dealer_id.id, 'name': self.name, 'vqir_date':self.vqir_date, 'preapproved_date': self.preapproved_date, 'payment_receipt': self.payment_receipt, 'vqir_type': self.vqir_type, 'vqir_service_type': self.vqir_service_type, 'vqir_state': 'submit', 'date_occur': self.date_occur, 'vqir_city': self.vqir_city, 'place_of_incident': self.place_of_incident, 'km_1st_trouble': self.km_1st_trouble, 'run_km': self.run_km, 'part': self.part, 'person': self.person, 'others': self.others, 'trouble_explanation': self.trouble_explanation, 'trouble_cause_analysis': self.trouble_cause_analysis, 'disposal_measures': self.disposal_measures, 'proposal_for_improvement': self.proposal_for_improvement, 'driver_name': self.driver_name, 'ss_name': self.ss_name, 'ss_street1': self.ss_street1, 'ss_street2': self.ss_street2, 'ss_city': self.ss_city, 'ss_phone': self.ss_phone, 'ss_mobile': self.ss_mobile, 'ss_fax': self.ss_fax, 'ss_email': self.ss_email, 'users_name': self.users_name, 'users_street1': self.users_street1, 'users_street2': self.users_street2, 'users_city': self.users_city, 'users_phone': self.users_phone, 'users_mobile': self.users_mobile, 'users_fax': self.users_fax, 'users_email': self.users_email, 'date_released': self.date_released, 'reps_name': self.reps_name, 'reps_street1': self.reps_street1, 'reps_street2': self.reps_street2, 'reps_city': self.reps_city, 'reps_phone': self.reps_phone, 'reps_mobile': self.reps_mobile, 'reps_fax': self.reps_fax, 'reps_email': self.reps_email, 'remarks': self.remarks, 'fos_fu_id': self.fos_fu_id.id, 'dealer_id': dealer_id, 'dealer_vqir_id': self.id, 'dealer_host': self.company_id.dealer_host, 'dealer_db': self.company_id.dealer_pgn, 'dealer_port': self.company_id.dealer_port, 'dealer_pgu': self.company_id.dealer_pgu, 'dealer_pgp': self.company_id.dealer_pgp, 'vqir_state_logs': self.vqir_state_logs, 'approved_date': self.approved_date, 'submitted_date': fields.datetime.now(), 'declined_date': self.declined_date, 'disapproved_date': self.disapproved_date, 'ack_date': self.ack_date, 'paid_date': self.paid_date, 'url': self.company_id.dealer_host.strip(), 'db' : self.company_id.dealer_pgn, 'username' : self.company_id.dealer_pgu, 'password' : self.company_id.dealer_pgp }]) if fmpi_vqir_id: logger.info("VQIR ID " + str(fmpi_vqir_id)) # vqir jobs and parts for ji in self.fos_vqir_parts_and_jobs_line: fmpi_vqir_parts_and_jobs_id = models.execute_kw(db, uid, password, 'fmpi.vqir.parts.and.jobs', 'create', [{ 'name': ji.name, 'fmpi_vqir_id': fmpi_vqir_id, 'si_number':ji.si_number, 'si_date':ji.si_date, 'parts_number': ji.part_id.name, 'parts_desc': ji.parts_desc, 'parts_qty': ji.parts_qty, 'parts_cost': ji.parts_cost, 'parts_with_fee': ji.parts_with_fee, 'parts_total': ji.parts_total, 'job_code': ji.job_code, 'job_code_desc': ji.job_code_desc, 'job_qty': ji.job_qty, 'job_cost': ji.job_cost, 'approved_amount': ji.approved_amount, 'dealer_pj_id': ji.id }]) # vqir images for img in self.fos_vqir_images_line: fmpi_vqir_images_id = models.execute_kw(db, uid, password, 'fmpi.vqir.images', 'create', [{ 'name': img.name, 'fmpi_vqir_id': fmpi_vqir_id, 'image': img.image, 'image_medium': img.image_medium, 'image_small': img.image_small, 'image_remarks': img.image_remarks, }])
def list_pypi_packages(): """ Returns a sorted list of all packages on PyPI using the xmlrpc interface """ client = xmlrpclib.ServerProxy('https://pypi.python.org/pypi') return sorted(client.list_packages())
def call_task(self, url, db, user_id, task_uuid, model, method, **kwargs): odoo = xmlrpc_client.ServerProxy('{}/xmlrpc/2/object'.format(url)) args = [task_uuid, model, method] _kwargs = copy.deepcopy(kwargs) # Needed in the retry (call), to hide _password. _kwargsrepr = copy.deepcopy(kwargs) password = _kwargs.get('_password') del _kwargs['_password'] celery_params = _kwargs.get('celery', {}) logger.info('{model} {method} - celery.task uuid: {uuid}'.format( model=model, method=method, uuid=task_uuid)) logger.info('{model} {method} - kwargs: {kwargs}'.format( model=model, method=method, kwargs=_kwargs)) try: logger.info( 'XML-RPC to Odoo server:\n\n' '- url: {url}\n' '- db: {db}\n' '- user_id: {user_id}\n' '- task_uuid: {task_uuid}\n' '- model: celery.task\n' '- method: rpc_run_task\n' '- args: {args}\n' '- kwargs {kwargs}\n'.format( url=url, db=db, user_id=user_id, task_uuid=task_uuid, model=model, method=method, args=args, kwargs=_kwargs)) response = odoo.execute_kw(db, user_id, password, 'celery.task', 'rpc_run_task', args, _kwargs) if (isinstance(response, tuple) or isinstance(response, list)) and len(response) == 2: code = response[0] result = response[1] else: code = OK_CODE result = response if code == TASK_NOT_FOUND: msg = "%s, database: %s" % (result, db) raise TaskNotFoundInOdoo(msg) elif code in (STATE_RETRY, STATE_FAILURE): retry = celery_params.get('retry') countdown = celery_params.get('countdown', 1) retry_countdown_setting = celery_params.get('retry_countdown_setting') retry_countdown_add_seconds = celery_params.get('retry_countdown_add_seconds', 0) retry_countdown_multiply_retries_seconds = celery_params.get('retry_countdown_multiply_retries_seconds', 0) # (Optionally) increase the countdown either by: # - add seconds # - countdown * retry requests # - retry requests * a given seconds if retry and retry_countdown_setting: if retry_countdown_setting == RETRY_COUNTDOWN_ADD_SECONDS: countdown = countdown + retry_countdown_add_seconds elif retry_countdown_setting == RETRY_COUNTDOWN_MULTIPLY_RETRIES: countdown = countdown * self.request.retries elif retry_countdown_setting == RETRY_COUNTDOWN_MULTIPLY_RETRIES_SECCONDS \ and retry_countdown_multiply_retries_seconds > 0: countdown = self.request.retries * retry_countdown_multiply_retries_seconds celery_params['countdown'] = countdown if retry: msg = 'Retry task... Failure in Odoo {db} (task: {uuid}, model: {model}, method: {method}).'.format( db=db, uuid=task_uuid, model=model, method=method) logger.info(msg) # Notify the worker to retry. logger.info('{task_name} retry params: {params}'.format(task_name=self.name, params=celery_params)) _kwargsrepr['_password'] = '******' _kwargsrepr = repr(_kwargsrepr) raise self.retry(kwargsrepr=_kwargsrepr, **celery_params) else: msg = 'Exit task... Failure in Odoo {db} (task: {uuid}, model: {model}, method: {method})\n'\ ' => Check task log/info in Odoo'.format(db=db, uuid=task_uuid, model=model, method=method) logger.info(msg) else: return (code, result) except Exception as e: """ A rather picky workaround to ignore/silence following exceptions. Only logs in case of other Exceptions. This also prevents concurrent retries causing troubles like concurrent DB updates (shall rollback) etc. - xmlrpc_client.Fault: Catches exception TypeError("cannot marshal None unless allow_none is enabled"). Setting allowd_none on the ServcerProxy won't work like expected and seems vague. - Retry: Celery exception notified to tell worker the task has been re-sent for retry. We don't want to re-retry (double trouble here). See also odoo/service/wsgi_server.py for xmlrpc.client.Fault (codes), e.g: RPC_FAULT_CODE_CLIENT_ERROR = 1 """ if isinstance(e, MaxRetriesExceededError): # TODO # After implementation of "Hide sensitive data (password) by argspec/kwargspec, a re-raise should happen. # For now it shows sensitive data in the logs. msg = '[TODO] Failure (caught) MaxRetriesExceededError: db: {db}, task: {uuid}, model: {model}, method: {method}.'.format( db=db, uuid=task_uuid, model=model, method=method) logger.error(msg) # Task is probably in state RETRY. Now set it to FAILURE. args = [task_uuid, 'FAILURE'] odoo.execute_kw(db, user_id, password, 'celery.task', 'rpc_set_state', args) elif not isinstance(e, Retry): # Maybe there's a also a way the store a xmlrpc.client.Fault into the Odoo exc_info field e.g.: # args = [xmlrpc_client.Fault.faultCode, xmlrpc_client.Fault.faultString] # odoo.execute_kw(db, user_id, password, 'celery.task', 'rpc_set_exception', args) # # Necessary to implement/call a retry() for other exceptions ? msg = '{exception}\n'\ ' => SUGGESTIONS: Check former XML-RPC log messages.\n'.format(exception=e) logger.error(msg) raise e
except: return None filenames = tar.getnames() py_files = [elem for elem in filenames if elem.endswith('.py')] for py_file in py_files: try: content = tar.extractfile(py_file).read().decode() yield content except: yield None pyx_files = [elem for elem in filenames if elem.endswith('.pyx')] if len(pyx_files) > 0: yield 'import cython' DEFAULT_CLIENT = xmlrpclib.ServerProxy('http://pypi.python.org/pypi') def extract_package(name, to='pypi-deps.txt', client=DEFAULT_CLIENT): tmpfilename = '/tmp/temp_py_package.tar.gz' with open(to, 'a') as fout: try: releases = client.package_releases(name) except Exception as e: print(e, "internet connection issues?") return if len(releases) == 0: return release = client.package_releases(name)[0] # use only latest release docs = client.release_urls(name, release) if len(docs) > 0:
import xmlrpc.client as xmlrpclib # For planetlab cental api from geopy.distance import geodesic import math import matplotlib.pyplot as plt # import localization as lx # from sklearn import datasets, linear_model # from .ipGeolocator import ipGeolocator as lx import netmetGeolocator as lx from sklearn.model_selection import train_test_split, cross_validate from sklearn.linear_model import LinearRegression, Ridge, Lasso from sklearn.metrics import mean_squared_error, r2_score #%% ############ Planetlab api_server = xmlrpclib.ServerProxy('https://www.planet-lab.eu/PLCAPI/', allow_none=True) auth = {} auth['AuthMethod'] = 'password' auth['Username'] = '******' auth['AuthString'] = 'xxxx' authorized = api_server.AuthCheck(auth) #%% plslice = api_server.GetSlices(auth)[0] slice_node_ids = plslice["node_ids"] slice_nodes = api_server.GetNodes(auth, slice_node_ids) all_nodes = api_server.GetNodes(auth) #%% ################ GET ALL NODES OF THE SLICE ##################### boot_nodes = list() all_boot_nodes = list() i = 0
def mapReduce(input_data, map_fn, reduce_fn, output_location): try: files = [] result = "" if (map_fn == "word_count_map"): response = requests.get(input_data) soup = BeautifulSoup(response.text, 'html.parser') logging.info('Parsing the input html file %s', input_data) s = "" count = 0 for link in soup.find_all('p'): s += link.text s_len = len(s) length = math.ceil(s_len // 3) file_input = textwrap.wrap(s, length) print(file_input) print(len(file_input)) logging.debug( 'Calling map_input to store input data in key-value store') result = map_input(file_input, map_fn) elif (map_fn == "inverted_index_map"): for i in input_data: response = requests.get(i) soup = BeautifulSoup(response.text, 'html.parser') s = "" for i in soup.find_all('p'): s += i.text s = textwrap.fill(s) files.append(s) result = map_input(files, map_fn) if (result.strip() == "STORED"): if (map_fn == "word_count_map"): creation_status, mapper_ips = create_instances("map") logging.info(creation_status) if (creation_status): time.sleep(80) logging.info('RPC call to word_count_mapper') logging.info(str(mapper_ips[0])) proxy_1 = xc.ServerProxy("http://%s:%s" % (str(mapper_ips[0]), str(9000)), allow_none=True) map_result_1 = proxy_1.spool(map_fn) print(map_result_1) proxy_2 = xc.ServerProxy("http://%s:%s" % (str(mapper_ips[1]), str(9001)), allow_none=True) map_result_2 = proxy_2.spool(map_fn) print(map_result_2) proxy_3 = xc.ServerProxy("http://%s:%s" % (str(mapper_ips[2]), str(9002)), allow_none=True) map_result_3 = proxy_3.spool(map_fn) print(map_result_3) else: logging.error("Mapper instance creation failed") exit(0) elif (map_fn == "inverted_index_map"): creation_status, mapper_ips = create_instances("map") if (creation_status): time.sleep(80) logging.info('RPC call to inverted_index_mapper') proxy_1 = xc.ServerProxy("http://%s:%s" % (str(mapper_ips[0]), str(9000)), allow_none=True) map_result_1 = proxy_1.spool(map_fn) print(map_result_1) proxy_2 = xc.ServerProxy("http://%s:%s" % (str(mapper_ips[1]), str(9001)), allow_none=True) map_result_2 = proxy_2.spool(map_fn) print(map_result_2) proxy_3 = xc.ServerProxy("http://%s:%s" % (str(mapper_ips[2]), str(9002)), allow_none=True) map_result_3 = proxy_3.spool(map_fn) print(map_result_3) else: logging.error("Mapper instance creation failed") exit(0) if (map_result_1 and map_result_2 and map_result_3): result = terminate_instances("map") if (result): logging.info("Termination of mapper instances successful") else: logging.error("Instances termination failed") logging.info('Map task successfully completed') logging.debug('Calling shuffle in master') shuffle_result = shuffle(map_fn) logging.info('The response of shuffle in master is %s', str(shuffle_result)) shuffle_result = shuffle_result.strip() if (shuffle_result == "STORED"): logging.info('Shuffle task successfully completed') if (reduce_fn == "word_count_reduce"): creation_status, reducer_ips = create_instances( "reduce") if (creation_status): time.sleep(80) logging.info('RPC call to word_count reducer') proxy = xc.ServerProxy( "http://%s:%s" % (str(reducer_ips[0]), str(9005)), allow_none=True) reducer_result_1 = proxy.spool(reduce_fn) print(reducer_result_1) proxy = xc.ServerProxy( "http://%s:%s" % (str(reducer_ips[1]), str(9006)), allow_none=True) reducer_result_2 = proxy.spool(reduce_fn) print(reducer_result_2) proxy = xc.ServerProxy( "http://%s:%s" % (str(reducer_ips[2]), str(9007)), allow_none=True) reducer_result_3 = proxy.spool(reduce_fn) print(reducer_result_3) else: logging.error("Reducer instance creation failed") exit(0) elif (reduce_fn == "inverted_index_reduce"): creation_status, reducer_ips = create_instances( "reduce") if (creation_status): time.sleep(80) logging.info('RPC call to inverted_index_reducer') proxy_1 = xc.ServerProxy( "http://%s:%s" % (str(reducer_ips[0]), str(9005)), allow_none=True) reducer_result_1 = proxy_1.spool(reduce_fn) proxy_2 = xc.ServerProxy( "http://%s:%s" % (str(reducer_ips[1]), str(9006)), allow_none=True) reducer_result_2 = proxy_2.spool(reduce_fn) proxy_3 = xc.ServerProxy( "http://%s:%s" % (str(reducer_ips[2]), str(9007)), allow_none=True) reducer_result_3 = proxy_3.spool(reduce_fn) print(reducer_result_1) print(reducer_result_2) print(reducer_result_3) else: logging.error("Reducer instance creation failed") exit(0) if (reducer_result_1 and reducer_result_2 and reducer_result_3): result = terminate_instances("reduce") if (result): logging.info( "Termination of reducer instances successful") else: logging.error("Instances termination failed") logging.info('Reduce task successfully completed') res = store_output_file(reduce_fn, output_location) if (res): logging.info( 'The output of the map reduce task has been stored in the file %s', output_location) res = backup() if (res): logging.info( 'Map reduce task successfully completed') print("Map reduce task successfully completed") task_completed = True else: logging.error("Backup failed") else: logging.error('Reducer task %s' % str(reduce_fn) + 'failed') else: logging.error('Mapper task %s' % str(map_fn) + 'failed') else: logging.error('Storing input data in server failed') except Exception as e: logging.error("Exception occurred", exc_info=True) return task_completed
from pathos import logger logger(level=20, name='pathos.xmlrpc') # logging.INFO logger(level=20, name='pathos.selector') # logging.INFO if __name__ == '__main__': import os, time try: import xmlrpc.client as client except ImportError: import xmlrpclib as client s = XMLRPCServer('', 0) print('port=%d' % s.port) port = s.port pid = os.fork() if pid > 0: #parent def add(x, y): return x + y s.register_function(add) s.activate() #s._selector._info.activate() s.serve() else: #child time.sleep(1) s = client.ServerProxy('http://localhost:%d' % port) print('1 + 2 = %s' % s.add(1, 2)) print('3 + 4 = %s' % s.add(3, 4)) # End of file
if __name__ == "__main__": print( '*************************\nRpcServer Startup\n**************************' ) start = time.clock() mp = mp.Process(target=RpcServer) mp.start() end = time.clock() print('Elapsed Time - RpcServer Startup: %.3f\n' % (end - start)) time.sleep(1) hostname = '127.0.0.1' port = 9000 server = xrc.ServerProxy('http://' + hostname + ':' + str(port), allow_none=True, use_builtin_types=True) print('*************************\nGetHauls\n**************************') start = time.clock() hauls = server.get_hauls() if hauls: print('count: ' + str(len(hauls))) for haul in hauls: # haul = [x.decode('utf-8') if isinstance(x, bytes) else x for x in haul] print(str(haul)) end = time.clock() print('Elapsed Time - GetHauls: %.3f\n' % (end - start)) # RpcServer - Shutdown print(
def __init__(self): """Initialize the BQValidation object.""" pypi_org = xmlrpclib.ServerProxy('https://pypi.python.org/pypi') self.pypi_org_packages = {nn(p) for p in pypi_org.list_packages()}
def get_db_list(self, host, port, context={}): uri = 'http://' + host + ':' + port conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/db') db_list = execute(conn, 'list') return db_list
def schedule(worker_ips, train_partitions, valid_partitions, train_availability, valid_availability, input_fn, model_fn, train_fn, initial_msts, mst_eval_fn, ckpt_root='/tmp', preload_data_to_mem=True, backend='tf'): """ :param workers: :param train_partitions: :param valid_partitions: :param train_availability: :param valid_availability: :param input_fn: :param model_fn: :param train_fn: :param initial_msts: :param mst_eval_fn: :param ckpt_root: :param preload_data_to_mem: """ begin_time = time.time() print('Starting HT job: ' + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) if os.path.exists("./logs"): shutil.rmtree("./logs") os.makedirs("./logs") scheduler_log_file = open("./logs/scheduler.log", "w") workers = {i: xc.ServerProxy(ip) for i, ip in enumerate(worker_ips)} current_msts = [(mst_id, mst) for mst_id, mst in enumerate(initial_msts)] mst_evaluation_state = {} if os.path.exists(ckpt_root): shutil.rmtree(ckpt_root) for mst_id, mst in current_msts: ckpt_path = ckpt_root + "/" + str(mst_id) + "_" + uuid() if not os.path.exists(ckpt_path): os.makedirs(ckpt_path) ckpt_path = ckpt_path + "/model" mst_evaluation_state[mst_id] = { "state": "RUNNING", "epoch": -1, "train_error": [], "train_loss": [], "valid_error": [], "valid_loss": [], "ckpt_path": ckpt_path, "mst": mst } log_file = open("./logs/" + str(mst_id) + ".log", 'a') log_message(log_file, "Checkpoint Path: " + ckpt_path + "\n") log_message(log_file, "MST: " + mst_identifier(mst) + "\n") if backend == 'tf': exec_fn_string = base64.b64encode( dill.dumps(tf_execute_helper, byref=False)).decode("ascii") elif backend == 'pytorch': exec_fn_string = base64.b64encode( dill.dumps(pytorch_execute_helper, byref=False)).decode("ascii") preload_fn_string = base64.b64encode( dill.dumps(preload_data_helper, byref=False)).decode("ascii") input_fn_string = base64.b64encode(dill.dumps(input_fn, byref=False)).decode("ascii") model_fn_string = base64.b64encode(dill.dumps(model_fn, byref=False)).decode("ascii") train_fn_string = base64.b64encode(dill.dumps(train_fn, byref=False)).decode("ascii") if preload_data_to_mem: # preload data into the worker memory preload_data(workers, input_fn_string, preload_fn_string, train_partitions, valid_partitions, train_availability, valid_availability, scheduler_log_file, begin_time) # assume # train partitions = # valid. partitions P = len(train_partitions) W = len(workers) random.seed = 2019 def _get_runnable_unit(epoch_units, w, availability, epoch_mst_execution_state): random.shuffle(epoch_units) for idx, (mst_id, mst, partition) in enumerate(epoch_units): if availability[w][partition] == 1 and ( epoch_mst_execution_state[mst_id] == False): del epoch_units[idx] return mst_id, mst, partition return -1, -1, -1 iteration = 0 while len(current_msts) > 0: epoch_mst_evaluation_state = { mst_id: { "train_error": [], "train_loss": [], "valid_error": [], "valid_loss": [] } for mst_id, mst in current_msts } for mode, availability, partitions in zip( ["TRAIN", "VALID"], [train_availability, valid_availability], [train_partitions, valid_partitions]): epoch_units = [(mst_id, mst, partition) for partition in range(P) for (mst_id, mst) in current_msts] epoch_mst_execution_state = { mst_id: False for mst_id, _ in current_msts } epoch_machine_state = [None for _ in range(W)] epoch_begin_time = time.time() while len(epoch_units) > 0 or sum( [1 for x in epoch_machine_state if x is not None]) > 0: for w in [w for w in range(W) if w in workers]: try: if epoch_machine_state[w] is None: mst_id, mst, p = _get_runnable_unit( epoch_units, w, availability, epoch_mst_execution_state) if mst_id != -1: exec_id = launch_job( workers[w], mst_evaluation_state[mst_id]['epoch'] + 1, [p], mst_evaluation_state[mst_id]['ckpt_path'], [partitions[p]], input_fn_string, model_fn_string, train_fn_string, exec_fn_string, mst, mode == "TRAIN") epoch_mst_execution_state[mst_id] = True epoch_machine_state[w] = (mst_id, mst, p, exec_id) message = "TIME: %d, EVENT: %s_LAUNCHED, ITERATION: %d, WORKER: %d, MST: %d, PARTITIONS: %s, EPOCH: %d, %s\n" % ( time.time() - begin_time, mode, iteration, w, mst_id, "/".join([str(x) for x in [p]]), mst_evaluation_state[mst_id]['epoch'] + 1, mst_identifier(mst)) log_message(scheduler_log_file, message, print_message=True) elif epoch_machine_state[w] is not None: mst_id, mst, p, exec_id = epoch_machine_state[w] completed, status = check_finished( workers[w], exec_id) if completed: epoch_mst_execution_state[mst_id] = False epoch_machine_state[w] = None log_file = open( "./logs/" + str(mst_id) + ".log", 'a') log_message(log_file, status["result"]["message"]) loss = status["result"]["loss"] error = status["result"]["error"] if mode == "TRAIN": epoch_mst_evaluation_state[mst_id][ 'train_loss'].extend(loss) epoch_mst_evaluation_state[mst_id][ 'train_error'].extend(error) else: epoch_mst_evaluation_state[mst_id][ 'valid_loss'].extend(loss) epoch_mst_evaluation_state[mst_id][ 'valid_error'].extend(error) message = "TIME: %d, EVENT: %s_COMPLETED, ITERATION: %d, WORKER: %d, MST: %d, PARTITIONS: %s, EPOCH: %d, %s\n" % ( time.time() - begin_time, mode, iteration, w, mst_id, "/".join([str(x) for x in [p]]), mst_evaluation_state[mst_id]['epoch'] + 1, mst_identifier(mst)) log_message(scheduler_log_file, message, print_message=True) except Exception as e: print(e) print('Worker {0} failure detected....'.format(str(w))) # removing w from available workers workers.pop(w, None) # if there was any mst unit running, remove it back to the queue if epoch_machine_state[w] is not None: mst_id, mst, p, exec_id = epoch_machine_state[w] print( 'MST {0} partition {1} moved back to queue....' .format(str(mst_id), str(p))) epoch_units.append((mst_id, mst, p)) epoch_machine_state[w] = None epoch_mst_execution_state[mst_id] = False # starting from beginning break # check failed workers are up again for w in range(W): if w not in workers: try: #print('Checking worker {0}....'.format(str(w))) con = xc.ServerProxy(worker_ips[w]) con.is_live() workers[w] = con epoch_machine_state[w] = None print('Worker {0} back online....'.format(str(w))) if preload_data_to_mem: # preload data into the worker memory preload_data([workers[w]], input_fn_string, preload_fn_string, train_partitions, valid_partitions, [train_availability[w]], [valid_availability[w]], scheduler_log_file, begin_time) except Exception as e: #print(e) continue sys.stdout.flush() time.sleep(config.POLLING_PERIOD) message = 'Iteration: {}, {} Elapsed Time: {}\n'.format( iteration, mode, time.time() - epoch_begin_time) log_message(scheduler_log_file, message, print_message=True) # update mst evaluation state mst_evaluation_state = update_mst_evaluation_state( epoch_mst_evaluation_state, mst_evaluation_state) # mst evaluation current_msts, mst_evaluation_state = evaluate_msts( mst_eval_fn, mst_evaluation_state, current_msts, ckpt_root) iteration += 1 print('Total HT job time: ' + str(time.time() - begin_time))
from xmlrpc import client as xmlrpclib ################################################## # XMLRPC client used to connect to odoo client # ################################################## # DB info url = 'http://127.0.0.1:8071' db = 'pos-db' username = '******' password = '******' common = xmlrpclib.ServerProxy('{}/xmlrpc/2/common'.format(url)) models = xmlrpclib.ServerProxy('{}/xmlrpc/2/object'.format(url)) uid = common.login(db, username, password) # Search and read records result = models.execute(db, uid, password, 'res.partner', 'search_read', [['id', '=', 1]]) number_of_customers = models.execute(db, uid, password, 'res.partner', 'search_count', []) print('Number of customers: ' + str(number_of_customers)) print('result: ' + str(result[0].get('name'))) # Create records id = models.execute_kw(db, uid, password, 'res.partner', 'create',
try: from xmlrpc import client as xmlrpclib except ImportError: import xmlrpclib DATABASE = 'andy_5_10' USERNAME = '******' PASSWORD = '******' common = xmlrpclib.ServerProxy('http://emipro:8998/xmlrpc/2/common') user_id = common.login(DATABASE, USERNAME, PASSWORD) print("========user_id", user_id) server = xmlrpclib.ServerProxy('http://emipro:8998/xmlrpc/2/object') aws_iot = server.execute_kw(DATABASE, user_id, PASSWORD, 'aws.iot.log.ept', 'check_iot', ['G030JF0524415HFV', 'DOUBLE']) print("********", aws_iot)
def test_unicode_host(self): server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT)) self.assertEqual(server.add("a", "\xe9"), "a\xe9")
#import xmlrpclib import xmlrpc.client as xmlrpclib HOST = 'localhost' PORT = 8011 DB = 'uber' USER = '******' PASS = '******' root = 'http://%s:%d/xmlrpc/' % (HOST, PORT) userid = xmlrpclib.ServerProxy(root + 'common').login(DB, USER, PASS) print("Logged in as %s (Userid: %d)" % (USER, userid)) #Create socket = xmlrpclib.ServerProxy(root + 'object') args = {'name': 'DemoAbc', 'email': '*****@*****.**'} #data_id = socket.execute(DB,userid,PASS,'guest.user','create',args) res = socket.execute(DB, userid, PASS, 'guest.user', 'write', [1], args)
def test_path2(self): p = xmlrpclib.ServerProxy(URL + "/foo/bar") self.assertEqual(p.add(6, 8), 6 + 8) self.assertRaises(xmlrpclib.Fault, p.pow, 6, 8)
def sync_products(): manager = mp.Manager() data_pool = manager.list() create_ids = manager.dict() write_ids = manager.dict() uom_ids = manager.dict() category_ids = manager.dict() location_ids = manager.dict() process_Q = [] fp = open('files/iclitem1.csv', 'r') csv_reader = csv.DictReader(fp) fp1 = open('files/ivlioh.csv', 'r') csv_reader1 = csv.DictReader(fp1) sock = xmlrpclib.ServerProxy(URL, allow_none=True) all_locations = sock.execute(DB, UID, PSW, 'stock.location', 'search_read', [('usage', '=', 'internal')], ['id', 'name']) all_locations = {ele['name']: ele['id'] for ele in all_locations} for vals in csv_reader1: if vals['BIN-CODE'] and vals['BIN-CODE'] in all_locations: location_ids[vals['ITEM-CODE']] = all_locations[vals['BIN-CODE']] default_codes = [] for vals in csv_reader: data_pool.append(vals) default_code = vals['ITEM-CODE'] default_codes.append(default_code) sale_uoms = {} fp2 = open('files/ivlitum1.csv', 'r') csv_reader2 = csv.DictReader(fp2) for line in csv_reader2: product = line.get('ITEM-CODE', '') code = str(line.get('UOM')) + '_' + str(line.get('QTY')) if product in sale_uoms: sale_uoms[product].append(code) else: sale_uoms[product] = [code] sale_uoms = manager.dict(sale_uoms) fp.close() domain = [('default_code', 'in', default_codes), '|', ('active', '=', False), ('active', '=', True)] res = sock.execute(DB, UID, PSW, 'product.product', 'search_read', domain, ['default_code']) write_ids = {rec['default_code']: rec['id'] for rec in res} uoms = sock.execute(DB, UID, PSW, 'uom.uom', 'search_read', [], ['id', 'name']) uom_ids = {uom['name']: uom['id'] for uom in uoms} categories = sock.execute(DB, UID, PSW, 'product.category', 'search_read', [], ['id', 'categ_code']) category_ids = { category['categ_code']: category['id'] for category in categories } res = None default_codes = None uoms = None categories = None for i in range(WORKERS): pid = "Worker-%d" % (i + 1) worker = mp.Process(name=pid, target=update_product, args=(pid, data_pool, create_ids, write_ids, uom_ids, category_ids, location_ids, sale_uoms)) process_Q.append(worker) worker.start() for worker in process_Q: worker.join()
def test_close(self): p = xmlrpclib.ServerProxy(self.url) self.assertEqual(p('close')(), None)
def update_product(pid, data_pool, create_ids, write_ids, uom_ids, category_ids, location_ids, sale_uoms): sock = xmlrpclib.ServerProxy(URL, allow_none=True) while data_pool: try: data = data_pool.pop() default_code = data.get('ITEM-CODE') code = str(data.get('ITEM-STOCK-UOM')) + '_' + str( data.get('ITEM-QTY-IN-STOCK-UM')) active = True purchase_ok = True # Comment out because inactive items break order imports if data.get('ITEM-STATUS') and data.get('ITEM-STATUS') == 'D': purchase_ok = False, if float(data.get('ITEM-QTY-ON-HAND')) <= 0.0: active = False sale_uom_ids = [] if default_code in sale_uoms: for uom in sale_uoms[default_code]: sale_uom_id = uom_ids.get(uom) if sale_uom_id: sale_uom_ids.append(sale_uom_id) else: logger.debug( 'SALE UOM missing uom:{0} product:{1}'.format( uom, default_code)) uom_id = uom_ids.get(code) if uom_id: sale_uom_ids.append(uom_id) else: logger.error('UOM missing uom:{0} product:{1}'.format( uom, default_code)) continue vals = { 'name': data.get('ITEM-DESC').title(), 'description_sale': data.get('ITEM-DESC').lower(), 'description_purchase': data.get('ITEM-DESCR2').lower(), 'default_code': default_code, 'categ_id': category_ids.get(data.get('PROD-CODE')), 'active': active, 'type': 'product', 'standard_price': data.get('ITEM-UNIT-COST'), 'sale_ok': True, 'taxes_id': [(6, 0, [3])], 'lst_price': data.get('ITEM-AVG-SELL-PRC'), 'purchase_ok': purchase_ok, 'sale_uoms': [(6, 0, sale_uom_ids)], 'uom_id': uom_ids.get(code), 'uom_po_id': uom_ids.get(code), 'volume': data.get('ITEM-CUBE'), 'weight': data.get('ITEM-WEIGHT'), 'property_stock_location': location_ids.get(default_code) } res = write_ids.get(default_code, []) if res: sock.execute(DB, UID, PSW, 'product.product', 'write', res, vals) print(pid, 'UPDATE - PRODUCT', res) else: res = sock.execute(DB, UID, PSW, 'product.product', 'create', vals) print(pid, 'CREATE - PRODUCT', res) except Exception as e: logger.error('Error {0} {1}'.format(vals, e))
def __init__(self): self.rat_client = client.ServerProxy("http://{0}:{1}".format(server_ip, server_port))
# # Make the call. # try: response = server.raw_request(stuff) pass except xmlrpclib.Fault as e: print (e.faultString) sys.exit(-1); pass print (str(response)); sys.exit(0); elif len(req_args): # Get a handle on the server, server = xmlrpclib.ServerProxy(URI, context=ctx) # Method and args are on the command line. sys.exit(do_method(server, req_args)) else: # Get a handle on the server, server = xmlrpclib.ServerProxy(URI, context=ctx) # Prompt the user for input. try: while True: line = raw_input("$ ") tokens = line.split(" ") if len(tokens) >= 1 and len(tokens[0]) > 0: print (str(do_method(server, tokens))) pass pass pass