def recurseDir(self,
dir_path,
file_action,
dir_action,
regular_files_only = False,
stop_on_first_error = True):
"""
recurse a directory doing actions
file_action on each file, and dir_action on each directory
these actions must return a Response object
dir_path is a string (starting path)
file_action is a callable which takes a path argument
(called for either all non-directory items or just
reguar files, depending on optional arg regular_files_only)
- or None if none required
dir_action is a callable which takes a path argument
(called for directories) - or None if none required -
NB this is just what to do with the directory entries
themselves - the recursion is already provided
optional arg stop_on_first_error should be self-explanatory
"""
resp = Response.success()
try:
entries = os.listdir(dir_path) # FIXME(?) could use self.listDir() and add
# "ignore dot files" functionality?
except Exception, err:
return Response.failure("%s: %s" % (Exception, err))
def broadcast(self,message,file=None,filename=None,toGroup='public'):
#fungsi ini bertugas melakukan broadcasting pesan atau file
newResponse = Res.Response(211)
content = {}
content['sender'] = self.name
content['message'] = message
if(file!=None):
newResponse.code = 212
content['file'] = file
content['filename'] = filename
content['toGroup'] = toGroup
newResponse.content = content
for friend in self.listfriends:
if friend.is_alive():
if toGroup in friend.myGroup:
if friend == self and file == None:
newResponse2= Res.Response(211)
content2 = {}
content2['sender'] = "YOU"
content2['message'] = message
content2['toGroup'] = toGroup
newResponse2.content = content2
self.sendMessage(newResponse2.encode())
else :
friend.sendMessage(newResponse.encode())
def update_restaurant(rest_id):
if 'Content-Type' not in request.headers or request.headers[
'Content-Type'] != 'application/json':
return Response.unsupported()
json = request.get_json()
s = db.Session()
rest = s.query(db.Restaurant).get(rest_id)
rest.name = json['name']
rest.address = json['address']
rest.owners = []
owners = json['owners']
for o in owners:
owner = None
if 'id' in o:
owner = s.query(db.Owner).get(o['id'])
if owner is None:
owner = db.Owner(o['name'], o['age'], o['gender'])
else:
owner = db.Owner(**o)
rest.owners.append(owner)
s.commit()
return Response.successful()
def answer(sentence):
index = sentence.index('where was')+2
text = nltk.word_tokenize(sentence)
val = nltk.pos_tag(text)
#print('Val',val)
#print('Index',index)
info = Response.getNextSoloTerm(val[index:],['VBN'])
subject = info[0]
index+=info[1]
#print('Subject',subject)
if subject=='arnold':
info = Response.getNextSoloTerm(val[index:],['NN'])
if info=="":
return randAnswer()
attribute = info[0]
index+=info[1]
#print('Attribute',attribute)
form=''
answer = Response.buildSentence([subject,'where was',attribute,form])
if answer=="":
return randAnswer()
return(answer)
elif subject=='movie':
return('Give me a break bro. I\'m not a genie. I\'m a simple chat bot')
else:
return randAnswer()
def yzm(req):
vc = VerifyCode()
data = vc.generate()
print(vc.code)
response = Response(req)
response.set_cookie('yzm', vc.code)
req.start_response(response.status, response.header)
return [data]
def delete(self, username):
db = client.sla
col = db.users
query = {"username" : username}
if(col.find_one(query)!=None):
user_id = col.delete_one(query)
return(Response(status=200)) #Success
return(Response(status=400)) #Bad request (username not found)
def execute_request(self, parameters, timeout):
parameters = urllib.urlencode(parameters)
request = urllib2.Request(self.end_point)
response = urllib2.urlopen(request, parameters, timeout)
try:
return Response(response)
except Exception:
return Response(None, 'ConnectionError', sys.exc_info()[0])
finally:
response.close()
def handle_file_upload(bucket_name, object_name, data, md5, size):
r = createBucket(bucket_name)
response = ast.literal_eval(r.content.decode("utf-8"))
if r.status_code == 400: return res.makeResponse(r.status_code, response)
r = createUploadTicket(bucket_name, object_name)
response = ast.literal_eval(r.content.decode("utf-8"))
if r.status_code == 400: return res.makeResponse(r.status_code, response)
r = uploadFile(bucket_name, object_name, 1, data, md5, size)[0]
response = ast.literal_eval(r.content.decode("utf-8"))
if r.status_code == 400: return res.makeResponse(r.status_code, response)
r = completeUploadTicket(bucket_name, object_name)
response = ast.literal_eval(r.content.decode("utf-8"))
return res.makeResponse(r.status_code, response)
def create_owner():
if 'Content-Type' not in request.headers or request.headers[
'Content-Type'] != 'application/json':
return Response.unsupported()
json = request.get_json()
owner = db.Owner(**json)
s = db.Session()
s.add(owner)
s.flush()
s.commit()
return Response.successful()
def get(self, Size):
app.logger.info('size is %d', Size)
if Size <= 0: #checking for negative or 0 Size and responding with appropriate error message and status code
app.logger.error('Invalid Size: Size must be a positive integer greater than 0 - status code 400')
return Response.Build_Json_Response('Invalid Size: Size must be a positive integer greater than 0',400)
elif Size >10000: # checking the max limit of size and responding with appropriate error message and status code
app.logger.error('Size cannot be greater than 10000. Please pass a positive integer < 10000 - status code 400')
return Response.Build_Json_Response('Size cannot be greater than 10000. Please pass a positive integer < 10000',400)
else: #generating the fibonacci sequence if size is valid
fib=str(GenerateFibonacci.Generate_Fibonacci(Size))
res=Response.Build_Json_Response(fib,200)
app.logger.info("generated fibonacci sequence %s - status code %d" , fib,res.status_code )
return res
def post(self):
request_json = request.get_json()
username = request_json['username']
password = request_json['password']
db = client.sla
col = db.users
match = re.match(pwd_validate, password)
if(col.find_one({"username" : username})==None and match!=None):
user_id=col.insert_one({"username" : username, "password" : password})
return(Response(status=201)) #Created
return(Response(status=400)) #Bad request: password/username error
def images_remove(id):
"""
Delete a specific image
"""
docker ('rmi', id)
resp = '{"id": "%s"}' % id
return Response(response=resp, mimetype="application/json")
def images_update(id):
"""
Update image attributes (support: name[:tag]) tag name should be lowercase only
curl -s -X PATCH -H 'Content-Type: application/json' http://localhost:8080/images/7f2619ed1768 -d '{"tag": "test:1.0"}'
"""
# resp = ''
return Response(response=resp, mimetype="application/json")
def write_envelope(version, filename):
envelope = Envelope(amfVersion=version)
message = Response(records)
envelope.__setitem__('message', message);
stream = remoting.encode(envelope)
file = open(filename, 'w+')
file.write(stream.getvalue())
def partial_response(path, start, end=None):
file_size = os.path.getsize(path)
if end is None:
end = file_size - start - 1
end = min(end, file_size - 1)
length = end - start + 1
with open(path, 'rb') as fd:
fd.seek(start)
bytes = fd.read(length)
assert len(bytes) == length
response = Response(
bytes,
206,
mimetype=mimetypes.guess_type(path)[0],
direct_passthrough=True,
)
response.headers.add(
'Content-Range', 'bytes {0}-{1}/{2}'.format(
start, end, file_size,
),
)
response.headers.add(
'Accept-Ranges', 'bytes'
)
return response
def _on_list_users(self, request: Request.ListUsers):
if request.client.state != Client.State.AUTHORIZED:
self.client_manager.remove_client(request.client)
return
request.client.send_response(
Response.UserList(self.client_manager.authorized_clients.values()))
def getMapIntent(req):
id = getId()
iduser = id + req.user
getMap({req.fieldMap: req.valueMap}, req.tablename, req.databasename,
iduser, req.long, req.lat, req.extrainfo)
r = response.Response(id, None)
return r.map
def swarm_index():
"""
List all nodes in the swarm
"""
output = docker'(docker node ls'')
resp = json.dumps(docker_ps_to_array(output))
return Response(response=resp, mimetype="application/json")
def connect(command):
receiver = command.struct['sender']
receiver = command.struct['args'][0]
if self.serverRegistry.sRegistry.has_key(receiver):
if sender == receiver:
send(Response(sender, 'Connect Fail: cannot connect to self'))
else:
Ysender = self.serverRegistry.sRegistry['sender']['public_key']
Yreceiv = self.serverRegistry.sRegistry['receiver'][
'public_key']
send(KeyExchange(receiver, Ysender, sender))
send(KeyExchange(sender, Yreceiv, receiver))
else:
send(
Response(sender,
'Connect Fail: user unavailable at the moment'))
def containers_show(id):
"""
Inspect specific container
"""
output = docker('ps -f',id)
resp = json.dumps(docker_ps_to_array(output))
return Response(response=resp, mimetype="application/json")
def execute(self):
logging.debug('params: %s'%q.parsed())
r = Response.error(return_code='0',
dimino6_return_code='0',
dimino6_error_message='There was an error.',
list=[])
return str(r)
def get_move(self):
print 'getting raw_response(sc)'
raw_response = self._socket.recv(4096)
print 'move: ' + raw_response
main_token = raw_response.split(MAIN_DELIM)
category_tokens = main_token[0].split(CATG_DELIM)
if len(category_tokens) == 4 or (len(category_tokens) == 5 and category_tokens[0] == ""):
self._turn_number += 1
player_turn = int(category_tokens[0])
raw_scores = category_tokens[1]
message = category_tokens[2]
raw_pieces = category_tokens[3].split(MOVE_DELIM)
else:
self._turn_number = int(category_tokens[0])
player_turn = int(category_tokens[1])
raw_scores = category_tokens[2]
message = category_tokens[3]
raw_pieces = category_tokens[4].split(MOVE_DELIM)
print 'player turn: ',player_turn
print 'message(sc):',message
print 'raw_scores: ',raw_scores
scores = [score for score in raw_scores.split(SCOR_DELIM)] #list comprehension ftw
print 'scores: ', scores
pieces = []
#if message.strip() != 'Starting Turn':
print 'raw pieces: ',raw_pieces
for piece in raw_pieces:
p = piece.split(VALU_DELIM)
pieces.append(GamePiece.GamePiece(int(p[0]), int(p[1]), int(p[2])))
print 'pieces: ',pieces
return Response.Response(self._turn_number, player_turn, scores, message, pieces)
def update_owner(owner_id):
if 'Content-Type' not in request.headers or request.headers[
'Content-Type'] != 'application/json':
return Response.unsupported()
json = request.get_json()
s = db.Session()
owner = s.query(db.Owner).get(owner_id)
owner.name = json['name']
owner.age = json['age']
owner.gender = json['gender']
s.commit()
return Response.successful()
def post(self):
request_json = request.get_json()
username = request_json['username']
password = request_json['password']
db = client.sla
users = db.users
response=Response()
user_doc=users.find_one({"username":username,"password":password})
if(user_doc!=None):
response.status_code=200
else:
response.status_code=403
return(response)
def handle_invalid_path(invalid_path):
app.logger.info('size is %s', invalid_path)
app.logger.error(
'Invalid Size: Size must be a positive integer greater than 0 - status code 400'
)
return Response.Build_Json_Response(
'Invalid Size: Size must be a positive integer greater than 0', 400)
def sendButtonListener(event=None):
EntryBox.bind("<Return>", lambda event: tempFrame.focus_set())
userInput = EntryBox.get()
if len(userInput) != 0:
ChatBox.insert("end", "You: " + userInput)
ChatBox.itemconfig('end', {'fg': 'blue'})
root.update_idletasks()
responseList = Response.getResponse(userInput, no_of_lines.get())
ChatBox.insert("end", "Bot: " + responseList[0])
ChatBox.itemconfig('end', {'fg': 'green'})
ChatBox.config(foreground="#446665", font=("Verdana", 12))
root.update_idletasks()
signUpWindow.update_idletasks()
for response in responseList[1:]:
ChatBox.insert("end", " " + response)
ChatBox.itemconfig('end', {'fg': 'green'})
ChatBox.config(foreground="#446665", font=("Verdana", 12))
root.update_idletasks()
signUpWindow.update_idletasks()
root.update_idletasks()
signUpWindow.update_idletasks()
mic_button.config(state='active')
response = "".join(responseList)
insertIntoDatabase("MsgStore", userEmailAddress, userInput)
insertIntoDatabase("MsgStoreHistory", userEmailAddress, userInput)
insertIntoDatabase("MsgStore", "bot" + userEmailAddress, response)
insertIntoDatabase("MsgStoreHistory", "bot" + userEmailAddress,
response)
EntryBox.delete(0, 'end')
global stringToSpeak
stringToSpeak = response
else:
return
def containers_remove(id):
"""
Delete a specific container - must be already stopped/killed
"""
container.stop(id)
docker ('rm',id)
resp = '{"id": "%s"}' % id
return Response(response=resp, mimetype="application/json")
def intent1():
query = "select tititu from library where prcolp='PRO';"
r = response.Response(
None,
'The result has more lines than allowed. Please download the result here:\n'
+ 'https://' + www + '.ngrok.io/files?id=20200824185330Sndr18')
res = r.simple
return res
def intent2():
query = 'select tititu from library;'
r = response.Response(
None,
"The result is:\nALU,\nDIG,\nENT,\nINS,\nINV,\nLEC,\nLECI,\nPRO,\nROB,\nTEL,\n"
)
res = r.simple
return res
def intent3():
query = "select tititu from library where prfpre='01/07/20' and prlesu='BCDIG';"
r = response.Response(
None,
"The result is: \nLas aventuras del joven Einstein ,\nLa vuelta al mundo en 80 días ,\nQuerido zoo ,\nI'm not a supermouse ,\nMarada : la mujer lobo ,\nPenny Dreadful causes a kerfuffle ,\nRecuerdos del ayer ,\nQue Dios nos perdone ,\nDogman ,\n"
)
res = r.simple
return res
def __init__(self, usi):
self.usi = usi.usi
self.r = Response.Response()
self.results = None
self.name = None
self.precursorMZ = None
self.numPeaks = None
self.peakList = None
def images_create():
"""
Create image (from uploaded Dockerfile)
curl -H 'Accept: application/json' -F file=@Dockerfile http://localhost:8080/images
"""
dockerfile = request.files['file']
# resp = ''
return Response(response=resp, mimetype="application/json")
def handleRequest(self, request, connection, host, port):
if (len(request.keys()) == 0):
return 0
log = Logger.Logger()
method = request['method']
route = request['route']
server = '{0}:{1}'.format(host, port)
referrer = request['Referer'] or ''
data = request['params'] or request['body']
host = request['Host']
log.log({
'method': method,
'timestamp': time.time(),
'server': server,
'host': host,
'referrer': referrer,
'url': route,
'data': data
})
response = Response.Response(connection, self.__host, self.__port)
if (not 'Host' in request.keys()):
return response.send400BadRequest()
if (not self.__router[method]):
if (not method in self.__router.getKnownMethods()):
return response.send405MethodNotAllowed()
return response.send503NotImplemented()
if (not self.__router[method].get(route)):
return response.send404NotFound()
contentType = request['Accept'] or request['Content-Type']
if ',' in contentType:
contentType = contentType.split(',')
for mimeType in contentType:
if (mimeType in self.__mimetypes.values()):
break
elif (not contentType or contentType == '*/*'):
'''this will go to next check'''
pass
elif (not contentType in self.__mimetypes.values()):
print('Not In MimyTypes')
return response.send406NotAcceptable()
elif (route != '/'):
isValid = False
resourceExtension = re.match('.*(\.[a-z]*)', route)
if (not resourceExtension):
return response.send406NotAcceptable()
resourceExtension = resourceExtension.group(1)
for mimeType in contentType:
if (mimeType == self.__mimetypes[resourceExtension]):
isValid = True
break
if (contentType == self.__mimetypes[resourceExtension]):
isValid = True
if (not isValid):
print('not a valid resource for type')
return response.send406NotAcceptable()
response.setStatusCode(200)
return self.__router[method].get(route)(request, response)
def test_response():
fail1 = Response.Response(Response.failure, "angst1")
fail2 = Response.failure("angst2")
succ1 = Response.Response(Response.success, "happiness1")
succ2 = Response.success("happiness2")
print Response.success, Response.failure, Response.success(), Response.failure()
print fail1, fail2, succ1, succ2
if fail1:
print "should not get here"
if succ1:
print "should get here"
print fail1 + fail2
print fail1 + succ2
print succ1 + fail2
print succ1 + succ2
def deleteDir(self, dir_path, **kwargs):
"""
Delete a directory recursively (akin to rm -fr)
Optional args (in particular stop_on_first_error) can be
passed to recurseDir()
"""
return (self.recurseDir(dir_path,
self.deleteFile,
self.deleteEmptyDir,
**kwargs)
and Response.success("%s deleted" % dir_path))
def answer(sentence):
index = sentence.index('when')+2
text = nltk.word_tokenize(sentence)
#print('Question',text)
val = nltk.pos_tag(text)
#print('Tokens',val)
#print(val)
info = Response.getNextSoloTerm(val[index:],['VBN','NN'])
if info=="":
#print("HERE WE GO")
return randAnswer()
subject = info[0]
index+=info[1]
#print('subject',subject)
if subject=='arnold':
info = Response.getNextSoloTerm(val[index:],['NN'])
if info=="":
return randAnswer()
#randNum = random.randint(0,len(randomAnswers)-1)
#return(randomAnswers[randNum])
attribute = info[0]
index+=info[1]
#print('ATTRIBUTE',attribute)
form = ''
answer = Response.buildSentence([subject,'when was',attribute,form])
if answer=="":
return randAnswer()
#randNum = random.randint(0,len(randomAnswers)-1)
#return(randomAnswers[randNum])
return(answer)
elif subject=='movie':
form = ''
#print('Form',form)
info = Response.getMovieTitle(val[index:],['VBN','VBD'])
if info=="":
return randAnswer()
title = info[0]
index = index + info[1]
#print('Title:',title)
info = Response.getNextTerm(val[index:],['VBN','VBD'])
if info=="":
return randAnswer()
attribute = info[0]
index = index + info[1]
#print('NEWcounter',counter)
#print('Attribute:',attribute)
answer = Response.buildSentence([subject,'when was',title,attribute,form])
if answer=="":
return randAnswer()
return answer
else:
return randAnswer()
def answer(sent):
#print(sent)
sent = sent.lower()
locTerms = ['city','country''province']
dateTerms = ['month','year','day','date']
curiousTerms = ['is','was']
if re.match('^(what).*$',sent):
tokes= nltk.pos_tag(nltk.word_tokenize(sent))
if tokes[1][0] in dateTerms:
#print('we\'re in the date object')
counter = 2
info = Response.getNextSoloTerm(tokes[counter:],['VBN','NN'])
if info=="":
return randAnswer()
subject = info[0]
counter = counter+info[1]
#print('Subject:',subject)
if subject =='movie':
form = tokes[1][0]
#print('Form',form)
info = Response.getMovieTitle(tokes[counter:],['VBN','VBD'])
if info=="":
return randAnswer()
title = info[0]
counter = counter + info[1]
#print('Title:',title)
info = Response.getNextTerm(tokes[counter:],['VBN','VBD'])
if info=="":
return randAnswer()
attribute = info[0]
counter = counter + info[1]
#print('NEWcounter',counter)
#print('Attribute:',attribute)
answer = Response.buildSentence([subject,'when was',title,attribute,form])
if answer=="":
return randAnswer()
return answer
elif subject=='arnold':
form = tokes[1][0]
#print('Form:',form)
info = Response.getNextTerm(tokes[counter:],['NN','NNP'])
if info=="":
return randAnswer()
attribute = info[0]
counter = counter + info[1]
#print('Attribute:',attribute)
#print('OBJECT:\nSubject: {}\nQuestType: when\nAttribute: {}\nForm: {}'.format(subject,attribute,form))
answer = Response.buildSentence([subject,'when was',attribute,form])
if answer=="":
return randAnswer()
return answer
elif tokes[1][0] in locTerms:
#print('we\'re in the location object')
counter = 2
info = Response.getNextSoloTerm(tokes[counter:],['VBN','NN'])
if info=="":
return randAnswer()
subject = info[0]
counter = counter+info[1]
#print('Subject:',subject)
if subject=='arnold':
form = tokes[1][0]
#print('Form:',form)
info = Response.getNextTerm(tokes[counter:],['NN','NNP'])
if info=="":
return randAnswer()
attribute = info[0]
counter = counter + info[1]
#print('Attribute:',attribute)
return Response.buildSentence([subject,'where was',attribute,form])
elif tokes[1][0] in curiousTerms:
return randAnswer()
#randNum = random.randint(0,len(randomAnswers))
#return(randomAnswers[randNum])
else:
return randAnswer()
def zipDir(self, *args, **kwargs):
"""
As _zipDir, but returns a Response object
"""
return Response.wrap(self._zipDir, *args, **kwargs)
def HandleClient(clientsock):
name = threading.currentThread().getName()
print name, ' Started.............'
global EOM
chunks=[]
while 1:
buf = clientsock.recv(2048)
chunks.append(str(buf))
if (EOM in chunks[-1]):
msg= "".join(chunks)[:-5]
if (msg=="TEST: HELLO"):
return
req =Request.parseRequest(msg)
if (not validReq(req)):
Response.sendData(clientsock,"Invalid Request")
print "invalid request"
clientsock.close()
return
if (req["requestType"]=="SUBMIT"):
job=Request.parseJob(msg)
global JOBS
if (req["Owner"]=="system" or req["Owner"]=="utils"):
res= PBS.run(job["command"],req["JobID"])
if req["Owner"]=="system":
Response.sendData(clientsock,"Done")
else:
Response.sendData(clientsock,res)
elif req["Owner"]=="ubuntu":
res= PBS.run("su ubuntu -c '"+job["command"]+"'",req["JobID"])
Response.sendData(clientsock,res)
elif req["Owner"]=="ehpcuser":
res= PBS.run("su ehpcuser -c '"+job["command"]+"'",req["JobID"])
Response.sendData(clientsock,res)
else:
print "command:" + job["command"]
# print "inputs:" + job["inputs"]
c = PBS.AddFileWrapper("direct",job["command"],job["inputs"],job["outputs"])
id= PBS.runAsPBSJob(req["Owner"],req["JobID"],c)
Response.sendData(clientsock,'recieved:'+id)
clientsock.close()
elif (req["requestType"]=="STATUS"):
status=Job.checkPBSstatus(req["JobID"])
Response.sendData(clientsock,Job.perpareJobStatusMessage(req,status))
elif (req["requestType"]=="FETCH"):
OutputList = Request.getOutputList(msg)
response = Response.generateResponse(msg,OutputList)
Response.sendData(clientsock,response)
elif (req["requestType"]=='UPLOAD'):
UploadDict = Request.parseUpload(msg)
for key, value in UploadFileData.iteritems():
createFile = open(key, "wb")
while True:
data = conn.recv(1024)
createFile.write(value)
createFile.close()
break
def HandleClient(clientsock):
import config
name = threading.currentThread().getName()
print name, ' Started.............'
global EOM
chunks = []
cmd=""
while 1:
buf = clientsock.recv(2048)
if len(buf)<6:
chunks[-1]+=buf
else:
chunks.append(str(buf))
if (EOM in chunks[-1]):
msg = "".join(chunks)[:-5]
if debug: print msg
if (msg == "TEST: HELLO"):
Response.sendData(clientsock,"Hello")
clientsock.close()
return
req = Request.parseRequest(msg)
if (not validReq(req)):
Response.sendData(clientsock, "Invalid Request")
print "invalid request"
clientsock.close()
return
if (req["requestType"]=="CLONE"):
job = Request.parseCloneJob(msg)
if job["scm"]=="git":
gclient=git.GIT(job["workdir"],job["repo"])
gclient.setKey(job["key"])
cmd=gclient.get_clone_cmd()
elif (req["requestType"] == "PULL"):
job = Request.parsePullJob(msg)
if job["scm"]=="git":
gclient=git.GIT(workdir=job["workdir"])
gclient.setKey(job["key"])
cmd=gclient.get_pull_cmd()
elif req["requestType"]=="LIST-TAGS":
job = Request.parseListTagsJob(msg)
if job["scm"]=="git":
gclient=git.GIT(workdir=job["workdir"])
gclient.setKey(job["key"])
cmd=gclient.get_list_tags_cmd()
result=[]
res=Common.run(cmd)
if "ERR:" in res:
Response.sendData(clientsock,res)
else:
for line in res.split("\n"):
try:
cmd="cd %s; git show %s"%(job["workdir"],line)
res=Common.run(cmd)
lines=res.split("diff --git ")[0]
info=lines.split("\n")
#print info
tag=info[0][4:]
tagger=info[1].split(": ")[1].split("<")[0].strip()
date=info[2].split(": ")[1].strip()
commit=info[6].split("commit ")[1]
result.append(",,".join([tag,tagger,date,commit]))
except:
pass
Response.sendData(clientsock,"\n".join(result))
return
elif req["requestType"] == "LIST-BRNACHS":
job = Request.parseListBranchsJob(msg)
if job["scm"] == "git":
gclient = git.GIT(workdir=job["workdir"])
cmd = gclient.get_list_branches()
result = []
res = Common.run(cmd)
if "ERR:" in res:
Response.sendData(clientsock, res)
else:
for line in res.split("\n"):
try:
if line!="":
result.append(line.replace("*","").strip())
except:
pass
#print result
Response.sendData(clientsock, "\n".join(result))
return
elif req["requestType"]=="LIST-COMMITS":
job = Request.parseGetCommitsJob(msg)
if job["scm"]=="git":
gclient=git.GIT(workdir=job["workdir"])
gclient.setKey(job["key"])
cmd=gclient.get_history_cmd(job["options"],limit=config.log_limit)
elif req["requestType"]=="SWITCH-TAG":
job = Request.parseSwitchTagJob(msg)
if job["scm"]=="git":
gclient=git.GIT(workdir=job["workdir"])
cmd=gclient.get_switch_to_tag_cmd(tag=job["tag"])
elif req["requestType"]=="SWITCH-COMMIT":
job = Request.parseSwitchCommitJob(msg)
if job["scm"]=="git":
gclient=git.GIT(workdir=job["workdir"])
cmd=gclient.switch_to_histroy_cmd(commit=job["commit"])
elif req["requestType"]=="DIFF-COMMIT":
job = Request.parseSwitchCommitJob(msg)
if job["scm"]=="git":
gclient=git.GIT(workdir=job["workdir"])
cmd=gclient.commit_diff_cmd(commit=job["commit"])
elif req["requestType"]=="LIST-CHANGES":
job = Request.parseGetChangeLog(msg)
if job["scm"] == "git":
gclient = git.GIT(workdir=job["workdir"])
cmd = gclient.get_changelog(since=job["options"]["since"], to=job["options"]["to"])
result = []
res = Common.run(cmd)
print res
if "ERR:" in res:
Response.sendData(clientsock, res)
else:
for line in res.split("\n"):
try:
if line != "":
result.append(line.replace("*", "").strip())
except:
pass
print result
Response.sendData(clientsock, "\n".join(result))
elif req["requestType"]=="DEPLOY":
print msg
job = Request.parseDeployJob(msg)
try:
config=yaml.safe_load(open(job["configFile"]))
autodeployer.deploy(config,job["workdir"])
res="Done"
except Exception as e:
res="ERR:"+traceback.format_exc()
if cmd!="":
print cmd
res=Common.run(cmd)
Response.sendData(clientsock,res)
if debug:
print "Ended,",res
else:
print "Ended"
clientsock.close()
break
def add(self, file):
try:
self.total += self.futils.getSize(file)
return Response.success()
except OSError:
return Response.failure()
