def setUp(self): super(TestFunctional, self).setUp() if self.ssl: self.tmp_root = self.useFixture(fixtures.TempDir()).path root_subject, root_key = self.create_cert('root') self.create_cert('server', root_subject, root_key) self.create_cert('client', root_subject, root_key) self.create_cert('worker', root_subject, root_key) self.server = gear.Server( 0, os.path.join(self.tmp_root, 'server.key'), os.path.join(self.tmp_root, 'server.crt'), os.path.join(self.tmp_root, 'root.crt')) self.client = gear.Client('client') self.worker = gear.Worker('worker') self.client.addServer('127.0.0.1', self.server.port, os.path.join(self.tmp_root, 'client.key'), os.path.join(self.tmp_root, 'client.crt'), os.path.join(self.tmp_root, 'root.crt')) self.worker.addServer('127.0.0.1', self.server.port, os.path.join(self.tmp_root, 'worker.key'), os.path.join(self.tmp_root, 'worker.crt'), os.path.join(self.tmp_root, 'root.crt')) else: self.server = gear.Server(0) self.client = gear.Client('client') self.worker = gear.Worker('worker') self.client.addServer('127.0.0.1', self.server.port) self.worker.addServer('127.0.0.1', self.server.port) self.client.waitForServer() self.worker.waitForServer()
def addtask(username, jenkinsurl, jobname, specifynode, build_params): mysql = mysqlLib() url = None try: param = (username, jenkinsurl, jobname, json.dumps(build_params), 0) n, last_id = mysql.add_task(param) print(u"INFO, job initial, 0") unique_id = last_id if (specifynode == 1): J = Jenkins(jenkinsurl) jobs = Jobs(J) job = jobs[jobname] build_params['UNIQUE_ID'] = unique_id invoke = job.invoke(build_params=build_params) print("INFO, specifynode true") elif (specifynode == 0): client = gear.Client() client.addServer(gear_server, port=gear_port) client.waitForServer( ) # Wait for at least one server to be connected build_params['UNIQUE_ID'] = unique_id job = gear.Job('build:' + jobname, json.dumps(build_params)) client.submitJob(job) print("INFO, specifynode false") param = (1, unique_id) mysql.update_task_status(param) print(u"INFO, job submit, 1") print(u"INFO, job unique id :" + str(unique_id)) url = "http://10.48.55.39:8889/jobstatus/?job=" + str(unique_id) print(u"INFO, you could link " + url + " to trace the job status") except Exception as e: print(e) finally: mysql.close() return url
def launch(user, template_id): try: pm_list = InternalAPI.get_user_permissions_on_resource( user, RS_TEM, template_id) if not pm_list[PM_LAUNCH_TEMPLATE]: return False, ARK_ERRMSG_CONTENT[1201] tem = JobTemplate.objects.get(id=template_id) # 先在数据库里创建一条job记录,再向gearman发一个任务 job = Job.objects.create( name=tem.name, description='play', status='pending', start_time=timezone.now(), #end_time=timezone.now(), extra_variables=tem.extra_variables, result='', user=user, job_template=tem, ) client = gear.Client() client.addServer(settings.GEARMAN_SERVER, 4730) client.waitForServer() job.status = 'running' job.save() inv = tem.inventory inv_file = os.path.join(settings.INVENTORY_DIR, str(inv.id) + '_' + str(job.id) + '.yaml') with open(inv_file, 'w') as f: f.write(inv.gen_content()) job_data = { 'callback_url': settings.CALLBACK_HOST + reverse('job:remote_update', kwargs={'job_id': job.id}), 'inventory_file': inv_file, 'playbook_file': os.path.join(settings.PROJECT_DIR, str(tem.project.id), tem.playbook), 'args': { 'extra_variables': json.loads(tem.extra_variables), 'limit': tem.limit, 'forks': str(tem.forks), 'job_tags': tem.job_tags if tem.job_tags != '' else None, 'verbosity': '2', "check": False, }, } gearman_job = gear.Job('run_playbook', bytes(json.dumps(job_data), 'utf-8')) client.submitJob(gearman_job, background=True) return True, None except Exception as e: return False, str(e)
def gearmanjobstop(unique_id): datalist_info = {} output = None try: client = gear.Client() client.addServer(gear_server, port=gear_port) client.waitForServer() # Wait for at least one server to be connected param = {"id": unique_id} mysql = mysqlLib() datalist = mysql.query_task(param) mysql.close() jobname = datalist[0][3] status = datalist[0][5] build_number = datalist[0][6] if (int(status) == 2): build_params = {"name": jobname, "number": str(build_number)} job = gear.Job("stop:" + gear_server, json.dumps(build_params)) client.submitJob(job) print("INFO, job aborte start") output = "INFO, job aborte start" else: print("INFO, job not running now") output = "INFO, job not running now" except Exception as e: print(e) output = "ERROR, " + str(e) finally: datalist_info['output'] = output return datalist_info
def main(self): gclient = gear.Client() gclient.addServer(self.args.server) gclient.waitForServer() # Wait for at least one server to be connected if not isinstance(self.args.params, dict): build_params = simplejson.loads(self.args.params) else: build_params = self.args.params for x in range(0, int(self.args.jobs)): job_id = uuid.uuid4().hex build_params.update({'uuid': job_id}) gjob = gear.Job(self.args.function, simplejson.dumps(build_params), unique=job_id) if self.args.wait: print "\n" + time.asctime(time.localtime(time.time())) print "Sending job: " + self.args.function + " to " + self.args.server + " with params=" + str( build_params) gclient.submitJob(gjob) # wait for last job to complete before exiting if self.args.wait: finished = False while True: if (gjob.complete): print time.asctime(time.localtime(time.time())) print "Job Result: " + str(gjob.data) + "\n" finished = True time.sleep(1) if finished: break
def __init__(self, client_id=None, worker_id=None, dsn=None): super(GearhornWorker, self).__init__(client_id=client_id, worker_id=worker_id) client_client_id = (client_id or worker_id) + '_broadcaster' self._servers = [] self.client = gear.Client(client_id=client_client_id) self._store = sqla.Store(dsn)
def setUp(self): super(TestGearhornWorker, self).setUp() self.server = server.TestServer() self.addCleanup(self.server.shutdown) self.client = gear.Client('in_client') self.addCleanup(self.client.shutdown) self.client.addServer('localhost', self.server.port) self.client.waitForServer()
def gearmanjob(gearman_srv_list, jobname, build_params): client = gear.Client() for item in gearman_srv_list: item_list = item.split(":") client.addServer(item_list[0], port=int(item_list[1])) client.waitForServer() # Wait for at least one server to be connected job = gear.Job('build:' + jobname, json.dumps(build_params)) client.submitJob(job)
def __init__(self, server, port, ssl_key=None, ssl_cert=None, ssl_ca=None): self.log.debug("Connecting to gearman at %s:%s" % (server, port)) self.gearman = gear.Client() self.gearman.addServer(server, port, ssl_key, ssl_cert, ssl_ca, keepalive=True, tcp_keepidle=60, tcp_keepintvl=30, tcp_keepcnt=5) self.log.debug("Waiting for gearman") self.gearman.waitForServer()
def setUp(self): super(TestFunctionalText, self).setUp() self.server = gear.Server(0) self.client = gear.Client('client') self.worker = gear.TextWorker('worker') self.client.addServer('127.0.0.1', self.server.port) self.worker.addServer('127.0.0.1', self.server.port) self.client.waitForServer() self.worker.waitForServer()
def setup_processors(self): for publisher in self.config['zmq-publishers']: gearclient = gear.Client() gearclient.addServer('localhost') gearclient.waitForServer() processor = EventProcessor(publisher, gearclient, self.config['source-files'], self.source_url) self.processors.append(processor)
def __init__(self, server, port, config, success, log_url, host_vars): self.client = gear.Client() self.client.addServer(server, port) self.hosts = host_vars self.zuul = list(host_vars.values())[0]['zuul'] self.success = success self.log_url = log_url self.matchers = [] for f in config['files']: self.matchers.append(FileMatcher(f['name'], f.get('tags', [])))
def test_handleStatusRes_2(self): client = gear.Client() packet = gear.Packet(gear.constants.RES, gear.constants.STATUS_RES, b'H:127.0.0.1:11\x001\x000\x00\x00') packet.getJob = lambda: gear.Job("", "") job = client.handleStatusRes(packet) self.assertTrue(job.known) self.assertFalse(job.running)
def main(): c = gear.Client() parser = argparse.ArgumentParser(description='Trigger a Zuul job.') parser.add_argument('--job', dest='job', required=True, help='Job Name') parser.add_argument('--project', dest='project', required=True, help='Project name') parser.add_argument('--pipeline', dest='pipeline', default='release', help='Zuul pipeline') parser.add_argument('--refname', dest='refname', help='Ref name') parser.add_argument('--oldrev', dest='oldrev', default='0000000000000000000000000000000000000000', help='Old revision (SHA)') parser.add_argument('--newrev', dest='newrev', help='New revision (SHA)') parser.add_argument('--url', dest='url', default='http://zuul.openstack.org/p', help='Zuul URL') parser.add_argument('--logpath', dest='logpath', required=True, help='Path for log files.') args = parser.parse_args() data = { 'ZUUL_PIPELINE': args.pipeline, 'ZUUL_PROJECT': args.project, 'ZUUL_UUID': str(uuid4().hex), 'ZUUL_REF': args.refname, 'ZUUL_REFNAME': args.refname, 'ZUUL_OLDREV': args.oldrev, 'ZUUL_NEWREV': args.newrev, 'ZUUL_SHORT_OLDREV': args.oldrev[:7], 'ZUUL_SHORT_NEWREV': args.newrev[:7], 'ZUUL_COMMIT': args.newrev, 'ZUUL_URL': args.url, 'LOG_PATH': args.logpath, } c.addServer('127.0.0.1', 4730) c.waitForServer() job = gear.Job("build:%s" % args.job, json.dumps(data), unique=data['ZUUL_UUID']) c.submitJob(job, precedence=gear.PRECEDENCE_HIGH) while not job.complete: time.sleep(1)
def sync(user, project_id, password): try: pm_list = InternalAPI.get_user_permissions_on_resource( user, RS_PRO, project_id) if not pm_list[PM_SYNC_PROJECT]: return False, ARK_ERRMSG_CONTENT[1201] pro = Project.objects.get(id=project_id) # 先在数据库里创建一条job记录,再向gearman发一个任务 job = Job.objects.create( name='update_repo', description='sync git', status='pending', start_time=timezone.now(), end_time=timezone.now(), result='', user=user, job_template=None, ) client = gear.Client() client.addServer(settings.GEARMAN_SERVER, 4730) client.waitForServer() job.status = 'running' job.save() pro.last_sync_job = job pro.save() job_data = { 'callback_url': settings.CALLBACK_HOST + reverse('job:remote_update', kwargs={'job_id': job.id}), 'inventory_file': settings.GIT_SYNC_INVENTORY, 'playbook_file': settings.GIT_SYNC_PLAYBOOK, 'args': { 'extra_variables': { 'gituser': pro.username, 'gitpassword': password, 'giturl': pro.url.replace('https://', ''), 'gitbranch': pro.branch, }, }, } gearman_job = gear.Job('run_playbook', bytes(json.dumps(job_data), 'utf-8')) client.submitJob(gearman_job, background=True) return True, None except Exception as e: return False, str(e)
def main(self): gclient = gear.Client() gclient.addServer(self.args.server) gclient.waitForServer() # Wait for at least one server to be connected if not isinstance(self.args.params, dict): build_params = json.loads(self.args.params) else: build_params = self.args.params job_queue = deque() job = None num_jobs = int(self.args.iterations) offline_node = build_params.get("OFFLINE_NODE_WHEN_COMPLETE", "false") if (num_jobs > 1 and offline_node.lower()=="true"): print "WARN: Offline node requested multiple times, may need to online nodes to complete this request" print "\n" + time.asctime( time.localtime(time.time())) for x in range(0, num_jobs): job_id = uuid.uuid4().hex build_params.update({'uuid':job_id}) job = gear.Job(self.args.function, json.dumps(build_params), unique=job_id) print "Sending job: " + self.args.function + " to " + self.args.server + " with params=" + str(build_params) gclient.submitJob(job) job_queue.append(job) # wait for jobs to complete before exiting print ("\nWaiting for jobs to finish"), finished = False while True: sys.stdout.write('.') sys.stdout.flush() if (job.complete): print "\n\n----- Job Results (" + time.asctime(time.localtime(time.time())) + ") ------ \n" while (len(job_queue) != 0) : cjob = job_queue.popleft() if (cjob.failure or cjob.exception): # job request failed for some reason print cjob.unique + ' : Failed' else: print cjob.unique + ' : ' + str(cjob.data) finished = True time.sleep(1); if finished: break
'command', help="\n".join(sorted(map_cmd_class)), nargs=argparse.REMAINDER, action=GearAdminRequestAction) opts = parser.parse_args() req_class = map_cmd_class[opts.command] try: req = getattr(gear, req_class)() except AttributeError: sys.stderr.write("Command '%s' not implemented.\n" "gear.%s does not exist.\n" % (opts.command, req_class)) exit(1) client = gear.Client('zuul-gearman.py') client.addServer(opts.server) client.waitForServer() server = client.getConnection() exit_code = 1 try: server.sendAdminRequest(req, timeout=opts.timeout) print req.response exit_code = 0 except gear.TimeoutError: print "Server timeout exceeded (%s)" % opts.server finally: exit(exit_code)
def connect(host: str) -> Any: client = gear.Client() client.addServer(host, 4730, 'tls.key', 'tls.crt', 'ca.crt') client.waitForServer(timeout=10) return client
def test_double_shutdown(self): client = gear.Client() client.shutdown() client.shutdown()
def __init__(self, client_id): self.client_id = client_id self.worker = gear.Worker(client_id=client_id) client_client_id = '%s_subscriber' % (client_id) self.client = gear.Client(client_id=client_client_id)
def __init__(self, server, port, ssl_key=None, ssl_cert=None, ssl_ca=None): self.log.debug("Connecting to gearman at %s:%s" % (server, port)) self.gearman = gear.Client() self.gearman.addServer(server, port, ssl_key, ssl_cert, ssl_ca) self.log.debug("Waiting for gearman") self.gearman.waitForServer()
def __init__(self, server, port): self.log.debug("Connecting to gearman at %s:%s" % (server, port)) self.gearman = gear.Client() self.gearman.addServer(server, port) self.log.debug("Waiting for gearman") self.gearman.waitForServer()
import gear def check_request_status(job): if job.complete: print "Job %s finished! Result: %s" % (job.name, job.data) elif job.warning: print "Job %s warning! exception: %s" % (job.name, job.exception) elif job.failure: print "Job %s failed! exception: %s" % (job.name, job.exception) client = gear.Client() client.addServer('192.168.122.89') client.waitForServer() job = gear.Job("reverse", "test string") client.submitJob(job) check_request_status(job)
def __init__(self, server, port): self.gearman = gear.Client('FakeZuul') self.gearman.addServer(server, port) self.gearman.waitForServer() self.job = None
def test_wait_for_server_timeout(self): client = gear.Client('client') client.addServer('127.0.0.1', 0) self.assertRaises(gear.TimeoutError, client.waitForServer, timeout=1)