def post(self, request, format=None):
project_name = json.loads(request.body).get('name', None)
if project_name is None:
raise ParamException('name')
project_type = json.loads(request.body).get('type', None)
if project_type is None:
raise ParamException('type')
config = json.loads(request.body).get('config', None)
if config is None:
raise ParamException('config')
setting = {'type': project_type, 'config': config}
self.update_project(project_name, setting)
project = self.get_project(project_name)
if project:
serializer = ServerProjectsSerializers(project)
response = {
'retcode': 0,
'retdata': serializer.data,
'retmsg': 'success'
}
return Response(response)
else:
response = {'retcode': -1, 'retmsg': 'failed'}
return Response(response)
def post(self, request, format=None):
moduleid = json.loads(request.body).get('moduleid', None)
if moduleid is None:
raise ParamException('moduleid')
name = json.loads(request.body).get('name', None)
if name is None:
raise ParamException('name')
type = json.loads(request.body).get('type', None)
if type is None:
raise ParamException('type')
version = json.loads(request.body).get('version', None)
if version is None:
raise ParamException('version')
module = self.get_object_id(moduleid)
module_dict = {
'id': moduleid,
'name': name,
'type': type,
'version': version
}
serializer = ModuleSerializers(module, data=module_dict)
if serializer.is_valid():
serializer.save()
data = {'retcode': 0, 'retdata': serializer.data}
return Response(data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
username = json.loads(request.body).get('username', None)
if username is None:
raise ParamException('username')
password = json.loads(request.body).get('password', None)
if password is None:
raise ParamException('password')
tag = json.loads(request.body).get('tag', None)
if tag is None:
raise ParamException('tag')
data = {
'serverId': serverId,
'username': username,
'password': password,
'tag': tag
}
serializer = MonitorMysqlUserSerializers(data=data)
if serializer.is_valid():
serializer.save()
data = {
'retcode': 0,
'retdata': serializer.data
}
return Response(data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
moduleid = json.loads(request.body).get('moduleid', None)
if moduleid is None:
raise ParamException('moduleid')
serverid = json.loads(request.body).get('serverid', None)
if serverid is None:
raise ParamException('serverid')
port = json.loads(request.body).get('port', None)
if port is None:
raise ParamException('port')
configfile = json.loads(request.body).get('configfile', None)
if configfile is None:
raise ParamException('configfile')
detail = self.get_detail(serverid, moduleid)
if detail:
self.update_detail(port, configfile, serverid, moduleid)
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg, status=status.HTTP_201_CREATED)
else:
row = self.create_detail(port, configfile, serverid, moduleid)
if row:
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg, status=status.HTTP_201_CREATED)
else:
msg = {'retcode': -2, 'retmsg': 'update fail'}
return Response(msg)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
service = self.get_object(serverId)
service.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request, format=None):
containerId = json.loads(request.body).get('container_id', None)
if containerId is None:
raise ParamException('container_id')
dockerd_url = 'http://39.108.141.79:4000/containers/%s/top?ps_args=aux' % containerId
headers = {'Content-Type': 'application/json'}
r = requests.get(dockerd_url, headers=headers)
code = r.status_code
data = r.json()
payloads = []
# print data
if code == '200' or code == 200 or code == '204' or code == 204:
for i in range(len(data['Processes'])):
payload = {
'COMMAND': data['Processes'][i][-1],
'CPU': data['Processes'][i][2],
'MEM': data['Processes'][i][3],
}
payloads.append(payload)
response = {
'retcode': 0,
'retdata': payloads,
}
return Response(response)
else:
raise Http404('container is not exist')
def post(self, request, format=None):
moduleid = json.loads(request.body).get('moduleid', None)
if moduleid is None:
raise ParamException('moduleid')
serverid = json.loads(request.body).get('serverid', None)
if serverid is None:
raise ParamException('serverid')
is_actived = json.loads(request.body).get('is_actived', None)
if is_actived is None:
raise ParamException('is_actived')
active = self.active_detail(moduleid, serverid, is_actived)
if active:
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg, status=status.HTTP_201_CREATED)
else:
msg = {'retcode': -1, 'retmsg': 'this record is not exist'}
return Response(msg, status=status.HTTP_201_CREATED)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
data = self.get_com_data(serverId)
if data:
msg = {'retcode': 0, 'retdata': data, 'retmsg': 'success'}
return Response(msg)
def post(self, request, format=None):
moduleId = json.loads(request.body).get('moduleid', None)
if moduleId is None:
raise ParamException('moduleid')
serverId = json.loads(request.body).get('serverid', None)
if moduleId is None:
raise ParamException('serverid')
data = self.get_module_server(moduleId, serverId)
if data:
datas = []
datas.append(data)
msg = {'retcode': 0, 'retdata': datas}
return Response(msg, status=status.HTTP_201_CREATED)
else:
msg = {'retcode': -1, 'retmsg': 'this record is not exist'}
return Response(msg, status=status.HTTP_201_CREATED)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
funcId = json.loads(request.body).get('funcId', None)
if funcId is None:
raise ParamException('funcId')
is_actived = json.loads(request.body).get('is_actived', None)
if is_actived is None:
raise ParamException('is_actived')
update = self.update_active(serverId, funcId, is_actived)
if update:
msg = {
'retcode': 0,
'retmsg': 'success'
}
return Response(msg)
def post(self, request, format=None):
hostip = json.loads(request.body).get('hostip', None)
if hostip is None:
raise ParamException('hostip')
# print hostip
datas = MonitorMemStat.objects.filter(hostip=hostip).order_by('-created')[:10]
serializer = MemStatSerializers(datas, many=True)
response = {
'retcode': 0,
'retdata': serializer.data
}
return Response(response)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
is_monitor = json.loads(request.body).get('is_monitor', None)
if is_monitor is None:
raise ParamException('is_monitor')
server = self.get_object(serverId)
data = {
'id': serverId,
'is_monitor': is_monitor
}
serializer = ServerSerializers(server, data=data)
if serializer.is_valid():
serializer.save()
msg = {
'retcode': 0,
'retdata': serializer.data
}
return Response(msg, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
containerId = json.loads(request.body).get('container_id', None)
if containerId is None:
raise ParamException('container_id')
dockerd_url = 'http://39.108.141.79:4000/containers/%s' % containerId
r = requests.delete(dockerd_url)
code = r.status_code
if code == '200' or code == 200 or code == '204' or code == 204:
ServerContainer.objects.filter(container_id=containerId).delete()
response = {'retcode': 0, 'retmsg': 'delete success'}
return Response(response)
else:
raise Http404('container is not exist')
def post(self, request, format=None):
containerId = json.loads(request.body).get('container_id', None)
if containerId is None:
raise ParamException('container_id')
dockerd_url = 'http://39.108.141.79:4000/containers/%s/start' % containerId
headers = {'Content-Type': 'application/json'}
r = requests.post(dockerd_url, headers=headers)
code = r.status_code
if code == '200' or code == 200 or code == '204' or code == 204:
response = {'retcode': 0, 'retmsg': 'start success'}
return Response(response)
else:
raise Http404('container is not exist')
def post(self, request, format=None):
clusterid = json.loads(request.body).get('clusterid', None)
if clusterid is None:
raise ParamException('clusterid')
cluster = self.get_object_id(clusterid)
if cluster:
delete = cluster.delete()
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg)
else:
msg = {'retcode': -4, 'retmsg': 'this record is not exist'}
return Response(msg)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
user = self.get_object(serverId)
serializer = MonitorMysqlUserSerializers(user, many=True)
if user:
data = {
'retcode': 0,
'retdata': serializer.data
}
return Response(data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
func = self.get_server_func_by_id(serverId)
# print inspect.stack()[0][3]
# print func
data = {
'retcode': 0,
'retdata': func
}
return Response(data)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
server = self.get_object(serverId)
# print server
serializer = ServerDetailSerializers(server, many=True)
# print serializer.data
data = {
'retcode': 0,
'retdata': serializer.data
}
return Response(data)
def post(self, request, format=None):
bussinessid = json.loads(request.body).get('bussinessid', None)
if bussinessid is None:
raise ParamException('bussinessid')
bussiness = self.get_object_id(bussinessid)
bussiness.delete()
if self.get_object_id(bussinessid):
msg = {'retcode': -1, 'retmsg': 'fail to delete'}
return Response(msg, status=status.HTTP_204_NO_CONTENT)
else:
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
funcId = json.loads(request.body).get('funcId', None)
if funcId is None:
raise ParamException('funcId')
data = {
'serverId': serverId,
'funcId': funcId
}
serializer = ServerMonitorFuncRelationSerializers(data=data)
if serializer.is_valid():
serializer.save()
data = {
'retcode': 0,
'retdata': serializer.data
}
return Response(data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
sevice = self.get_object(serverId)
serializer = ServerSeviceSerializers(sevice, data=request.data)
if serializer.is_valid():
serializer.save()
data = {
'retcode': 0,
'retdata': serializer.data
}
return Response(data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
# print request.data
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
name = json.loads(request.body).get('name', None)
alias = json.loads(request.body).get('alias', None)
tag = json.loads(request.body).get('tag', None)
cpu = json.loads(request.body).get('cpu', None)
mem = json.loads(request.body).get('mem', None)
hdd = json.loads(request.body).get('hdd', None)
global_ip = json.loads(request.body).get('global_ip', None)
private_ip = json.loads(request.body).get('private_ip', None)
system = json.loads(request.body).get('system', None)
netflow = json.loads(request.body).get('netflow', None)
server_dict = {
'name': name,
'alias': alias,
'tag': tag
}
detail_dict = {
'cpu': cpu,
'mem': mem,
'hdd': hdd,
'global_ip': global_ip,
'private_ip': private_ip,
'system': system,
'netflow': netflow
}
server = self.get_server_object(serverId)
detail = self.get_detail_object(serverId)
server_serializer = ServerSerializers(server, data=server_dict)
if server_serializer.is_valid():
server_serializer.save()
detail_serializer = ServerDetailSerializers(detail, data=detail_dict)
if detail_serializer.is_valid():
detail_serializer.save()
msg = {
'retcode': 0,
'retdata': {
'base': server_serializer.data,
'detail': detail_serializer.data
}
}
return Response(msg, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
clusterid = json.loads(request.body).get('clusterid', None)
if clusterid is None:
raise ParamException('clusterid')
name = json.loads(request.body).get('name', None)
if name is None:
raise ParamException('name')
type = json.loads(request.body).get('type', None)
if type is None:
raise ParamException('type')
region = json.loads(request.body).get('region', None)
if region is None:
raise ParamException('region')
cluster = self.get_object_id(clusterid)
if cluster:
update = self.update_object(cluster, name, type, region)
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg)
else:
msg = {'retcode': -4, 'retmsg': 'this record is not exist'}
return Response(msg)
def _parse_request(self):
'''
解析请求参数
'''
# 从header中解析参数
try:
self.cmdid = int(self.request.headers.get('cmdid', 0))
except:
raise ParamException('cmdid')
try:
self.timestamp = long(self.request.headers.get('timestamp', 0))
except:
raise ParamException('timestamp')
# json解析
try:
json_body = json.loads(self.request.body)
except:
raise BaseException(BaseError.ERROR_COMMON_PARSE_JSON_FAILED)
# TODO: 过滤非法字符
# 参数校验
self.userid = json_body.get('userid')
if not verify_utils.is_int(self.userid):
raise ParamException('userid')
self.userkey = json_body.get('userkey')
if not verify_utils.is_string(self.userkey):
raise ParamException('userkey')
self.params = json_body.get('params')
if not verify_utils.is_dict(self.params):
raise ParamException('params')
def post(self, request, format=None):
moduleid = json.loads(request.body).get('moduleid', None)
if moduleid is None:
raise ParamException('moduleid')
module = self.get_module_object(moduleid)
detail = self.get_detail_object(moduleid)
relate = self.get_module_server_object(moduleid)
module.delete()
detail.delete()
relate.delete()
if self.get_module_object(moduleid):
msg = {'retcode': -1, 'retmsg': 'fail to delete'}
return Response(msg, status=status.HTTP_204_NO_CONTENT)
else:
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg)
def post(self, request, format=None):
bussinessid = json.loads(request.body).get('bussinessid', None)
if bussinessid is None:
raise ParamException('bussinessid')
name = json.loads(request.body).get('name', None)
operatorid = json.loads(request.body).get('operatorid', None)
productorid = json.loads(request.body).get('productorid', None)
bussiness = self.get_object_id(bussinessid)
if bussiness:
update = self.update_detail(bussiness, name, operatorid,
productorid)
msg = {'retcode': 0, 'retmsg': 'success'}
return Response(msg, status=status.HTTP_201_CREATED)
else:
msg = {'retcode': -1, 'retmsg': 'this record is not exist'}
return Response(msg)
def post(self, request, format=None):
name = json.loads(request.body).get('name', None)
if name is None:
raise ParamException('name')
comment = json.loads(request.body).get('comment', None)
data = {
'name': name,
'comment': comment
}
serializer = MonitorFunctionSerializers(data=data)
if serializer.is_valid():
serializer.save()
data = {
'retcode': 0,
'retdata': serializer.data
}
return Response(data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
project_name = json.loads(request.body).get('project', None)
if project_name is None:
raise ParamException('project')
project = self.get_id(project_name)
branch_url = 'http://39.108.141.79:10080/api/v3/projects/' + str(
project.pid
) + "/repository/branches?private_token=1__kd35zHaxPyx21BnX6"
r = requests.get(branch_url)
datas = r.json()
branches = []
for data in datas:
branch = {
'protected': data[u'protected'],
'name': data[u'name'],
}
branches.append(branch)
response = {'retcode': 0, 'retdata': branches}
return Response(response)
def post(self, request, format=None):
project_name = json.loads(request.body).get('project', None)
if project_name is None:
raise ParamException('project')
project = self.get_id(project_name)
tag_url = "http://39.108.141.79:10080/api/v3/projects/" + \
str(project.pid) + \
"/repository/tags?private_token=1__kd35zHaxPyx21BnX6"
r = requests.get(tag_url)
datas = r.json()
tags = []
for data in datas:
tag = {
'name': data[u'name'],
'message': data[u'message'],
}
tags.append(tag)
response = {'retcode': 0, 'retdata': tags}
return Response(response)
def post(self, request, format=None):
serverId = json.loads(request.body).get('serverId', None)
if serverId is None:
raise ParamException('serverId')
service = self.get_object(serverId)
# print server
serializer = ServerSeviceSerializers(service, many=True)
# print serializer.data
datas = []
for data in serializer.data:
service = {
'serverId': data.get('serverId', None),
'name': data.get('name', None),
'port': str(data.get('port', None)).replace('"', '').replace('[', '').replace(']', '').split(', '),
'version': data.get('version', None),
'is_actived': data.get('is_actived', None),
}
datas.append(service)
services = {
'retcode': 0,
'retdata': datas
}
return Response(services)
