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)
