def create_or_update_server_repository(db_session,
hostname,
server_type,
server_url,
username,
vrf,
server_directory,
password,
destination_on_host,
created_by,
server=None):
hostname = check_acceptable_string(hostname)
if server is None:
server = Server(created_by=created_by)
db_session.add(server)
server.hostname = hostname
server.server_type = server_type
server.server_url = server_url
server.username = username
server.password = password
server.vrf = vrf if (server_type == ServerType.TFTP_SERVER
or server_type == ServerType.FTP_SERVER) else ''
server.server_directory = server_directory
server.destination_on_host = destination_on_host if server_type == ServerType.SCP_SERVER else ''
db_session.commit()
return server
def test_post_non_unique_port(self):
mc = MinecraftDownload.create(
'1.7.4',
'https://s3.amazonaws.com/Minecraft.Download/versions/1.7.4/minecraft_server.1.7.4.jar'
)
self.server.key.delete()
self.log_in_admin()
self.assertEqual(0, Server.query().count())
self.assertEqual(0, Client.query().count())
response = self.post(
params={
'name': 'new server',
'version': mc.version,
'memory': '1G',
'motd': 'Welcome',
'white_list': True,
'server_port': 25565,
'idle_timeout': 10,
'eula_agree': True
})
response = self.post(
params={
'name': 'new server',
'version': mc.version,
'memory': '1G',
'motd': 'Welcome',
'white_list': True,
'server_port': 25565,
'idle_timeout': 10,
'eula_agree': True
})
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
self.assertOK(response)
def test_post_idle_timeout(self):
mc = MinecraftDownload.create(
'1.7.4',
'https://s3.amazonaws.com/Minecraft.Download/versions/1.7.4/minecraft_server.1.7.4.jar'
)
self.server.key.delete()
self.log_in_admin()
self.assertEqual(0, Server.query().count())
self.assertEqual(0, Client.query().count())
response = self.post(
params={
'name': 'new server',
'version': mc.version,
'memory': '1G',
'motd': 'Welcome',
'white_list': True,
'server_port': 25565,
'idle_timeout': 0,
'eula_agree': True
})
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
server = Server.query().get()
self.assertEqual('new server', server.name)
self.assertEqual(True, server.is_gce)
self.assertEqual('1G', server.memory)
self.assertEqual(0, server.idle_timeout)
mc_properties = server.mc_properties
self.assertEqual('Welcome', mc_properties.motd)
self.assertEqual(True, mc_properties.white_list)
self.assertEqual(25565, mc_properties.server_port)
self.assertRedirects(response,
'/servers/{0}'.format(server.key.urlsafe()))
def test_post_non_unique_port(self):
mc = MinecraftDownload.create(
'1.7.4',
'https://s3.amazonaws.com/Minecraft.Download/versions/1.7.4/minecraft_server.1.7.4.jar'
)
self.server.key.delete()
self.log_in_admin()
self.assertEqual(0, Server.query().count())
self.assertEqual(0, Client.query().count())
response = self.post(params={
'name': 'new server',
'version': mc.version,
'memory': '1G',
'motd': 'Welcome',
'white_list': True,
'server_port': 25565,
'idle_timeout': 10,
'eula_agree': True
})
response = self.post(params={
'name': 'new server',
'version': mc.version,
'memory': '1G',
'motd': 'Welcome',
'white_list': True,
'server_port': 25565,
'idle_timeout': 10,
'eula_agree': True
})
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
self.assertOK(response)
def test_post_idle_timeout(self):
mc = MinecraftDownload.create(
'1.7.4',
'https://s3.amazonaws.com/Minecraft.Download/versions/1.7.4/minecraft_server.1.7.4.jar'
)
self.server.key.delete()
self.log_in_admin()
self.assertEqual(0, Server.query().count())
self.assertEqual(0, Client.query().count())
response = self.post(params={
'name': 'new server',
'version': mc.version,
'memory': '1G',
'motd': 'Welcome',
'white_list': True,
'server_port': 25565,
'idle_timeout': 0,
'eula_agree': True
})
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
server = Server.query().get()
self.assertEqual('new server', server.name)
self.assertEqual(True, server.is_gce)
self.assertEqual('1G', server.memory)
self.assertEqual(0, server.idle_timeout)
mc_properties = server.mc_properties
self.assertEqual('Welcome', mc_properties.motd)
self.assertEqual(True, mc_properties.white_list)
self.assertEqual(25565, mc_properties.server_port)
self.assertRedirects(response, '/servers/{0}'.format(server.key.urlsafe()))
async def get_instance(self):
""" This returns a boto Instance resource; if boto can't find the instance or if no entry for instance in database,
it raises ServerNotFound error and removes database entry if appropriate """
logger.info("function get_instance for user %s" % self.user.name)
server = Server.get_server(self.user.name)
resource = await retry(boto3.resource,
"ec2",
region_name=SERVER_PARAMS["REGION"])
try:
ret = await retry(resource.Instance, server.server_id)
logger.info("return for get_instance for user %s: %s" %
(self.user.name, ret))
# boto3.Instance is lazily loaded. Force with .load()
await retry(ret.load)
if ret.meta.data is None:
raise ServerNotFound
return ret
except ClientError as e:
self.log.error("get_instance client error: %s" % e)
if "InvalidInstanceID.NotFound" not in str(e):
self.log.error("Couldn't find instance for user '%s'" %
self.user.name)
Server.remove_server(server.server_id)
raise ServerNotFound
raise e
async def get_volume(self):
""" This returns a boto volume resource for the case no volumewas found.
If boto can't find the volume or if no entry for instance in database,
it raises VolumeNotFound error and removes database entry if appropriate """
self.log.debug("function get_resource for user %s" % self.user.name)
server = Server.get_server(self.user.name)
resource = await retry(boto3.resource,
"ec2",
region_name=SERVER_PARAMS["REGION"])
try:
ret = await retry(resource.Volume, server.ebs_volume_id)
self.log.debug("return for get_volume for user %s: %s" %
(self.user.name, ret))
# boto3.Volume is lazily loaded. Force with .load()
await retry(ret.load)
if ret.meta.data is None:
Server.remove_server(server.server_id)
self.log.info("\nVolume DNE for user %s\n" % self.user.name)
raise VolumeNotFound
return ret
except ClientError as e:
self.log.error("get_instance client error: %s" % e)
if "InvalidInstanceID.NotFound" not in str(e):
self.log.error("Couldn't find volume for user '%s'" %
self.user.name)
Server.remove_server(server.server_id)
raise VolumeNotFound
raise e
def test_view(self):
"""
test getting one server
"""
clear_db()
s1 = Server.create(server_id=None, tenant_id=1, name="name1", status="ready")
Server.create(server_id=None, tenant_id=1, name="name2", status="scheduled")
Server.create(server_id=None, tenant_id=2, name="name3", status="ready")
request = HTTPRequest(
self.get_url("/1/servers/" + str(s1.server_id)),
method="GET",
headers=HTTPHeaders({"X-AUTH-TOKEN": X_AUTH_TOKEN}),
)
self.http_client.fetch(request, self.stop)
response = self.wait()
message = json.loads(response.body)
assert message == {
"status": s1.status,
"id": s1.server_id,
"name": s1.name,
"date_created": str(s1.date_created),
}
def server_detail(request, name):
"""
Get, udpate, or delete a specific task
"""
try:
server = Server.objects.get(server_name=name)
except Server.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = ServerSerializer(server)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = ServerSerializer(server, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
Server.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def create_new_instance(self):
""" Creates and boots a new server to host the worker instance."""
self.log.debug("function create_new_instance %s" % self.user.name)
ec2 = boto3.client("ec2", region_name=SERVER_PARAMS["REGION"])
resource = boto3.resource("ec2", region_name=SERVER_PARAMS["REGION"])
boot_drive = {'DeviceName': '/dev/sda1', # this is to be the boot drive
'Ebs': {'VolumeSize': SERVER_PARAMS["WORKER_EBS_SIZE"], # size in gigabytes
'DeleteOnTermination': True,
'VolumeType': 'gp2', # This means General Purpose SSD
# 'Iops': 1000 } # i/o speed for storage, default is 100, more is faster
}
}
# create new instance
reservation = yield retry(
ec2.run_instances,
ImageId=SERVER_PARAMS["WORKER_AMI"],
MinCount=1,
MaxCount=1,
KeyName=SERVER_PARAMS["KEY_NAME"],
InstanceType=SERVER_PARAMS["INSTANCE_TYPE"],
SubnetId=SERVER_PARAMS["SUBNET_ID"],
SecurityGroupIds=SERVER_PARAMS["WORKER_SECURITY_GROUPS"],
BlockDeviceMappings=[boot_drive],
)
instance_id = reservation["Instances"][0]["InstanceId"]
instance = yield retry(resource.Instance, instance_id)
Server.new_server(instance_id, self.user.name)
yield retry(instance.wait_until_exists)
# add server tags; tags cannot be added until server exists
yield retry(instance.create_tags, Tags=WORKER_TAGS)
yield retry(instance.create_tags, Tags=[{"Key": "User", "Value": self.user.name}])
# start server
# blocking calls should be wrapped in a Future
yield retry(instance.wait_until_running)
return instance
def transform_backends_from_config(config):
register = {}
for entry in config.get('hosts', []):
register.update({entry["host"]: [Server(endpoint) for endpoint in entry["servers"]]})
for entry in config.get('paths', []):
register.update({entry["path"]: [Server(endpoint) for endpoint in entry["servers"]]})
return register
def servers_post():
"""
CREATE new server from POST data.
args:
- none
expected request json:
- {'name': str, 'notes': str, 'cluster_id': int, 'is_active': bool}
returns:
- response with json payload and http status code
"""
try:
data = request.json
keys = ['name', 'notes', 'is_active', 'cluster_id']
server = Server()
for key in keys:
if key not in data:
continue
setattr(server, key, data[key])
server.insert()
return jsonify({'success': True, 'servers': [server.as_dict()]}), 200
except Exception as err:
abort(422, str(err))
def test_weighted():
backend1 = Server("localhost:8081")
backend2 = Server("localhost:8082")
backend3 = Server("localhost:8083")
servers = [backend1, backend2, backend3]
weights = [1, 2, 3]
result = weighted(servers, weights)
assert result in servers
def change_center(request):
attr = request.POST.get('type', '')
if attr == 'report':
Server.change_report()
return JsonResponse({'code':0})
elif attr == 'mode':
Server.change_mode()
return JsonResponse({'code':0})
else:
print 'ERROR PARAM:', attr
def create_new_instance(self):
""" Creates and boots a new server to host the worker instance."""
self.log_user("create_new_instance()")
ec2 = boto3.client("ec2", region_name=SERVER_PARAMS["REGION"])
resource = boto3.resource("ec2", region_name=SERVER_PARAMS["REGION"])
BDM = []
boot_drive = {'DeviceName': '/dev/sda1', # this is to be the boot drive
'Ebs': {'VolumeSize': SERVER_PARAMS["WORKER_EBS_SIZE"], # size in gigabytes
'DeleteOnTermination': True,
'VolumeType': 'gp2', # This means General Purpose SSD
# 'Iops': 1000 } # i/o speed for storage, default is 100, more is faster
}
}
BDM = [boot_drive]
if SERVER_PARAMS["USER_HOME_EBS_SIZE"] > 0:
user_drive = {'DeviceName': '/dev/sdf', # this is to be the user data drive
'Ebs': {'VolumeSize': SERVER_PARAMS["USER_HOME_EBS_SIZE"], # size in gigabytes
'DeleteOnTermination': False,
'VolumeType': 'gp2', # General Purpose SSD
}
}
BDM = [boot_drive, user_drive]
# prepare userdata script to execute on the worker instance
user_home_device = "xvdf" if SERVER_PARAMS["USER_HOME_EBS_SIZE"] > 0 else ""
user_data_script = WORKER_USER_DATA.format(user=self.user.name, device=user_home_device)
# create new instance
reservation = yield retry(
ec2.run_instances,
ImageId=SERVER_PARAMS["WORKER_AMI"],
MinCount=1,
MaxCount=1,
KeyName=SERVER_PARAMS["KEY_NAME"],
InstanceType=SERVER_PARAMS["INSTANCE_TYPE"],
SubnetId=SERVER_PARAMS["SUBNET_ID"],
SecurityGroupIds=SERVER_PARAMS["WORKER_SECURITY_GROUPS"],
BlockDeviceMappings=BDM,
UserData=user_data_script,
max_retries=30,
)
self.log_user("result of retry(ec2.run_instances): %s" % reservation)
instance_id = reservation["Instances"][0]["InstanceId"]
instance = yield retry(resource.Instance, instance_id)
Server.new_server(instance_id, self.user.name)
yield retry(instance.wait_until_exists)
# add server tags; tags cannot be added until server exists
yield retry(instance.create_tags, Tags=WORKER_TAGS)
yield retry(instance.create_tags, Tags=[{"Key": "owner", "Value": self.user.name}])
# start server
# blocking calls should be wrapped in a Future
yield retry(instance.wait_until_running)
return instance
def profile(request):
host = get_server_host()
port = request.get_port()
user = request.user
if not user.is_superuser:
print "ERROR"
return HttpResponseRedirect('/account/logout/')
page_num = request.GET.get('page_num', 1)
page_num = int(page_num)
page_size = 6
offset = page_size * (page_num - 1)
server = Server.objects.filter(user_id=user.id).first()
host = host + ':' + port
server.host = host
if not server.work:
server_init()
server.work = 1
server.save()
count = Room.objects.filter(host=server.host).count()
page_count = (count + page_size - 1)/ page_size
if page_count < 1:
page_count = 1
if offset > count:
offset = count
if offset + page_size > count:
page_size = count - offset
rooms = Room.objects.filter(host=server.host)[offset:(offset+page_size)]
data = []
for room in rooms:
is_service = u'服务中'
is_link = u'已连接'
if not room.service:
is_service = u'未服务'
if not room.link:
is_link = u'连接已断开'
room_mode = MODE_DICT[MODE[Server.get_attr('mode')]]
room_speed = SPEED_DICT[SPEED[room.speed]]
data.append({
'id': room.id,
'is_link': is_link,
'numbers':room.numbers,
'ip_address': room.ip_address,
'service': is_service,
'mode': room_mode,
'speed': room_speed,
'power': CostPerDay.get_power(room.id, back=Server.get_report_days()),
'room_temperature': room.room_temperature,
'setting_temperature': room.setting_temperature,
'total_cost': CostPerDay.get_cost(room.id, back=Server.get_report_days()),
'rest_cost': room.total_cost,
})
return render(request, 'center.html', {'list': data, 'page_num':page_num, 'page_count':
page_count, 'user':user, 'host': host, 'report': Server.get_report_name(), 'mode':
MODE_DICT[MODE[server.mode]]})
def test_post(self):
self.server.key.delete()
self.log_in_admin()
self.assertEqual(0, Server.query().count())
self.assertEqual(0, Client.query().count())
response = self.post(params={'name': 'new server'})
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
server = Server.query().get()
self.assertEqual('new server', server.name)
self.assertEqual(False, server.is_gce)
self.assertRedirects(response, '/servers/{0}'.format(server.key.urlsafe()))
def test_post(self):
self.server.key.delete()
self.log_in_admin()
self.assertEqual(0, Server.query().count())
self.assertEqual(0, Client.query().count())
response = self.post(params={'name': 'new server'})
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
server = Server.query().get()
self.assertEqual('new server', server.name)
self.assertEqual(False, server.is_gce)
self.assertRedirects(response,
'/servers/{0}'.format(server.key.urlsafe()))
def test_least_connections():
backend1 = Server('localhost:8081')
backend1.open_connections = 10
backend2 = Server('localhost:8082')
backend2.open_connections = 5
backend3 = Server('localhost:8083')
backend3.open_connections = 2
servers = [backend1, backend2, backend3]
result = least_connections(servers)
assert result == backend3
def test_transform_backends_from_config():
input = yaml.safe_load('''
hosts:
- host: www.mango.com
servers:
- localhost:8081
- localhost:8082
- host: www.apple.com
servers:
- localhost:9081
- localhost:9082
paths:
- path: /mango
servers:
- localhost:8081
- localhost:8082
- path: /apple
servers:
- localhost:9081
- localhost:9082
''')
output = transform_backends_from_config(input)
assert list(output.keys()) == [
"www.mango.com", "www.apple.com", "/mango", "/apple"
]
assert output["www.mango.com"][0] == Server("localhost:8081")
assert output["www.mango.com"][1] == Server("localhost:8082")
assert output["www.apple.com"][0] == Server("localhost:9081")
assert output["www.apple.com"][1] == Server("localhost:9082")
assert output["/mango"][0] == Server("localhost:8081")
assert output["/mango"][1] == Server("localhost:8082")
assert output["/apple"][0] == Server("localhost:9081")
assert output["/apple"][1] == Server("localhost:9082")
def test_transform_backends_from_config():
input = yaml.safe_load('''
hosts:
- host: www.mango.com
servers:
- localhost:8081
- localhost:8082
- host: www.apple.com
servers:
- localhost:9081
- localhost:9082
paths:
- path: /mango
servers:
- localhost:8081
- localhost:8082
- path: /apple
servers:
- localhost:9081
- localhost:9082
''')
output = transform_backends_from_config(input)
assert list(output.keys()) == [
'www.mango.com', 'www.apple.com', '/mango', '/apple'
]
assert output['www.mango.com'][0] == Server('localhost:8081')
assert output['www.mango.com'][1] == Server('localhost:8082')
assert output['www.apple.com'][0] == Server('localhost:9081')
assert output['www.apple.com'][1] == Server('localhost:9082')
assert output['/mango'][0] == Server('localhost:8081')
assert output['/mango'][1] == Server('localhost:8082')
assert output['/apple'][0] == Server('localhost:9081')
assert output['/apple'][1] == Server('localhost:9082')
def post(self):
server = Server(key_name=self.request.get('serverdomain'))
server.serverdomain = self.request.get('serverdomain')
if self.request.get('ssl') == "True":
server.ssl = True
else:
server.ssl = False
if self.request.get('notifywithprowl') == "True":
server.notifywithprowl = True
if self.request.get('notifywithemail') == "True":
server.notifywithemail = True
#server.notifywithprowl = self.request.get('notifywithtwitter')
server.email = users.get_current_user().email()
server.put()
self.redirect('/admin')
def test_get_healthy_server():
host = "www.apple.com"
healthy_server = Server("localhost:8081")
unhealthy_server = Server("localhost:8082")
unhealthy_server.healthy = False
register = {"www.mango.com": [healthy_server, unhealthy_server],
"www.apple.com": [healthy_server, healthy_server],
"www.orange.com": [unhealthy_server, unhealthy_server],
"/mango": [healthy_server, unhealthy_server],
"/apple": [unhealthy_server, unhealthy_server]}
assert get_healthy_server("www.mango.com", register) == healthy_server
assert get_healthy_server("www.apple.com", register) == healthy_server
assert get_healthy_server("www.orange.com", register) == None
assert get_healthy_server("/mango", register) == healthy_server
assert get_healthy_server("/apple", register) == None
def update_room_info():
mode = Server.get_attr('mode')
query = Room.objects.select_for_update().filter(host=Server.get_host(), link=1)
for room in query.all():
resp = query_room_temperature(room.ip_address, room.numbers)
if not room.link:
continue
if resp['code'] == 0:
room.setting_temperature = resp['setting_temperature']
room.room_temperature = resp['room_temperature']
else:
room.link = 0
room.service = 0
print "break link!"
speed = room.speed
room.save()
if not room.service:
continue
if (room.setting_temperature >= room.room_temperature + 0.1 and mode == 0) or (room.setting_temperature + 0.1 <= room.room_temperature and mode == 2):
room.service = 0
if room.service == 0:
old_cost = RoomRequest.objects.filter(room_id=room.id).order_by("-id").first()
old_cost.end_time = datetime.now()
old_cost.end_temperature = room.room_temperature
old_cost.save()
resp = post_to_client(room.ip_address, {'type':'stop', 'source': 'host'})
if room.service == 1:
update_cost(room.id, POWER_PER_MIN[room.speed], room.price)
room.power += POWER_PER_MIN[room.speed]
room.total_cost = room.power * room.price
room.save()
service_count = query.filter(service=1).count()
if service_count < 3:
rooms = query.filter(service=0, speed__gt=0).all()
for room in rooms:
speed = room.speed
if (room.setting_temperature >= room.room_temperature + 0.1 and mode == 0) or (room.setting_temperature + 0.1 <= room.room_temperature and mode == 2):
continue
resp = post_to_client(room.ip_address, {'type':'send', 'source':'host'})
if resp['code'] == 0:
room.service = 1
room_request = RoomRequest.objects.create(room_id=room.id, start_time=datetime.now(), power = 0, cost = 0, start_temperature=room.room_temperature, speed=speed)
print "start service"
room.start_service_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
room.save()
break
return JsonResponse({'code': 0})
def test_post_duplicate_none_port(self):
self.server.mc_properties.server_port = 25565
self.server.mc_properties.put()
self.log_in_admin()
self.mc = MinecraftDownload.create(
'1.7.4', 'https://s3.amazonaws.com/Minecraft.Download/versions/1.7.4/minecraft_server.1.7.4.jar'
)
self.server.version = self.mc.version
self.server.put()
response = self.post(
params={
'name': self.server.name,
'version': self.server.version,
'memory': '1G',
'server_port': '',
'idle_timeout': 10,
'eula_agree': True
}
)
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
server = self.server.key.get()
server = self.server.key.get()
self.assertIsNone(server.mc_properties.server_port)
self.assertRedirects(response, '/servers/{0}'.format(server.key.urlsafe()))
def manually_kill_server(user_name):
# Get our AWS server db's instance for the user
try:
server = Server.get_server(user_name)
app_log.debug("Checking server for %s manually..." % user_name)
except Server.DoesNotExist:
# it is not necessarily the case that a server will exist, we return early if that is the case.
app_log.warn("There is no matching, allocated server for user %s" %
user_name)
return
# get server instance information
resource = yield retry(boto3.resource,
"ec2",
region_name=SERVER_PARAMS["REGION"])
instance = yield retry(resource.Instance, server.server_id)
# instance object is lazy, run this to get full info...
yield retry(instance.load)
#stop server if state is running (possible states are stopped, stopping, pending, shutting-down, terminated, and running)
if instance.state["Name"] == "running":
retry(instance.stop)
app_log.info("manually killed server for user %s" % user_name)
else:
app_log.debug("server state for user %s is %s, no action taken" %
(user_name, instance.state["Name"]))
def create_and_add_server(rack_id, server_ip, ram):
"""
Создание нового сервера и добавление его в серверную стойку.
:param rack_id: id стойки
:param server_ip: назначенный ip
:param ram: объем оперативной памяти
:return: id созданного сервера
"""
tmp_session = get_session()
try:
rack = tmp_session.query(Rack).get(int(rack_id))
check_free_slots(rack)
new_server = Server(date_creation=datetime.now(),
date_last_changes=datetime.now(),
server_ip=check_ip(server_ip),
server_ram=ram,
server_core=SEVER_STANDART_CORE,
optical_port=False,
status=SEVER_STATUS_LIST[START_SERVER_STATUS])
tmp_session.add(new_server)
tmp_session.commit()
module_logger.info('Создан новый сервер с id=%s' % str(new_server.id))
add_server_to_rack(new_server.id, rack.id, new=True)
return new_server.id
except AttributeError:
module_logger.error('Ошибка указания ip создаваемого сервера.')
return False
except Exception as err:
module_logger.error(err)
return False
finally:
tmp_session.close()
def nominate(self):
if ServerManager.has_active_server():
return post_message(
'Someone else is already making tea, I\'ll save your nomination for later :smile:',
self.channel)
try:
slack_id = MENTION_RE.search(self.command_body).groups()[0]
except AttributeError:
return post_message('You must nominate another user to brew!',
self.channel)
nominated_user = UserManager.get_by_slack_id(slack_id)
if self.request_user.nomination_points < NOMINATION_POINTS_REQUIRED:
return post_message(
'You can\'t nominate someone unless you brew tea %s times!' %
NOMINATION_POINTS_REQUIRED, self.channel)
# Subtract nomination points from request user.
nominated_user.nomination_points -= NOMINATION_POINTS_REQUIRED
server = Server(user_id=nominated_user.id)
session.add(server)
session.flush()
session.add(Customer(user_id=self.request_user.id,
server_id=server.id))
session.commit()
brew_countdown.apply_async(countdown=BREW_COUNTDOWN,
args=(self.channel, ))
return post_message(
'%s has nominated %s to make tea! Who wants in?' %
(self.request_user.first_name, nominated_user.first_name),
self.channel)
def get_server_dict(self):
servers_ordered = {0: 'All'}
servers_to_order = Server.query().order(Server.name).fetch()
for server in servers_to_order:
servers_ordered[len(servers_ordered)] = server.name
return servers_ordered
async def on_message(self, message):
if message.author.bot or message.content is None:
return
u: User = session.query(User).filter(User.user == message.author.id)
if u.count() < 1:
user = User(user=message.author.id)
session.add(user)
session.commit()
if message.guild is not None and session.query(Server).filter_by(server=message.guild.id).first() is None:
server = Server(server=message.guild.id)
session.add(server)
session.commit()
server = None if message.guild is None else session.query(Server).filter(Server.server == message.guild.id).first()
user = session.query(User).filter(User.user == message.author.id).first()
try:
if await self.get_cmd(message, server, user):
logger.info('Command: ' + message.content)
except discord.errors.Forbidden:
try:
await message.channel.send(ENGLISH_STRINGS.get_string('no_perms_general'))
except discord.errors.Forbidden:
logger.info('Twice Forbidden')
def get_instance(self):
#""" This returns a boto Instance resource; if boto can't find the instance or if no entry for instance in database,
# it raises Server.DoesNotExist error and removes database entry if appropriate """
""" This returns a boto Instance resource; if no entry for the instance in database,then
it raises Server.DoesNotExist error. If the instance in the database but
boto can't find the instance, it raise 500 http error """
self.log_user("get_instance()")
server = Server.get_server(self.user.name)
resource = yield retry(boto3.resource, "ec2", region_name=SERVER_PARAMS["REGION"])
try:
ret = yield retry(resource.Instance, server.server_id)
self.log_user("get_instance: returned: %s" % ret)
# boto3.Instance is lazily loaded. Force with .load()
yield retry(ret.load)
if ret.meta.data is None:
self.log_user("get_instance: could not access instance", level=logging.ERROR)
raise web.HTTPError(500, "Couldn't access instance for user '%s'. Please try again in a few minutes" % self.user.name)
#Server.remove_server(server.server_id)
#raise Server.DoesNotExist()
return ret
except ClientError as e:
self.log_user("get_instance client error: %s" % e)
if "InvalidInstanceID.NotFound" not in str(e):
self.log_user("get_instance: could not find instance for user", level=logging.ERROR)
raise web.HTTPError(500, "Couldn't access instance for user '%s'. Please try again in a few minutes" % self.user.name)
#Server.remove_server(server.server_id)
#raise Server.DoesNotExist()
raise e
def parseargs():
parser = argparse.ArgumentParser()
#Arguments
#Must haves
parser = argparse.ArgumentParser()
parser.add_argument("-su","--serverUser", help= "server username", required = True, type = str)
parser.add_argument("-sp","--serverPass", help= "server password", required = True, type = str)
parser.add_argument("-sa","--serverAddress", help= "server addres",required = True, type = str)
parser.add_argument("-db","--database", help= "the name of your database",required = True, type = str)
parser.add_argument("-ak","--alpacaKey", help= "alpaca api key", required = True, type = str)
parser.add_argument("-ask","--alpacaSKey", help= "alpaca secret api key", required = True, type = str)
parser.add_argument("-akd","--alpacaKeydelta", help= "alpaca api key delta", required = True, type = str)
parser.add_argument("-askd","--alpacaSKeydelta", help= "alpaca secret api key delta", required = True, type = str)
parser.add_argument("-ake","--alpacaKeyecho", help= "alpaca api key echo", required = True, type = str)
parser.add_argument("-aske","--alpacaSKeyecho", help= "alpaca secret api key echo", required = True, type = str)
parser.add_argument("-ik","--iexKey", help= "Iex api key", required = True, type = str)
#Optional
parser.add_argument("-s","--startup",help="fetches 3m data if present", action='store_true')
parser.add_argument("-sprev","--startupPrevious",help="fetches previous data", action='store_true')
parser.add_argument("-wl","--watchlists",help="run watchlists at boot", action='store_true')
parser.add_argument("-pv","--posSize", help= "Max position size of a stock, default is 500", nargs = "?", default = 500, type = int)
parser.add_argument("-ps","--posValue", help= "Max value of a position of a stock, default is 5000", nargs = "?", default = 5000, type = int)
parser.add_argument("-ema","--exponentialmovingaverage", help= "ema for charlie/delta, default is 20", nargs = "?", default = 20, type = int)
args = parser.parse_args()
#Database variables
serverUser = args.serverUser
serverPass = args.serverPass
serverAddress = args.serverAddress
database = args.database
alpacaKey = args.alpacaKey
alpacaSKey = args.alpacaSKey
alpacaKeydelta = args.alpacaKeydelta
alpacaSKeydelta = args.alpacaSKeydelta
alpacaKeyecho = args.alpacaKeyecho
alpacaSKeyecho = args.alpacaSKeyecho
iexKey = args.iexKey
ema_time_period = args.exponentialmovingaverage
#Position variables
startup = args.startup
startupPrevious = args.startupPrevious
watchlists = args.watchlists
maxPosSize = args.posSize
maxPosValue = args.posValue
#important classes
server = Server(user = serverUser, password = serverPass, address = serverAddress, database = database)
apis = APIs(alpacaKey, alpacaSKey, iexKey)
apis_delta = APIs(alpacaKeydelta, alpacaSKeydelta, iexKey)
apis_echo = APIs(alpacaKeyecho, alpacaSKeyecho, iexKey)
return apis, server, startup, startupPrevious, watchlists, maxPosSize, maxPosValue, apis_delta, apis_echo, ema_time_period
def __call__(self, form, field):
server = self.server or form.server
port = field.data
if port:
port = int(port)
if port in Server.reserved_ports(ignore_server=server):
raise validators.ValidationError("Port {0} is already reserved for another server".format(port))
async def leaderboard(message):
server = Server.get(Server.sid == message.server.id)
leaders = LocalLevel.select().where(
LocalLevel.server == server
).order_by(
LocalLevel.level.desc(), LocalLevel.experience.desc()
).limit(10)
lines = []
lines.append(
f"{'Username'.ljust(32)}{'Level'.ljust(8)}{'XP'.ljust(10)}"
)
for l in leaders:
m = message.server.get_member(f"{l.user.uid}")
req = ((8 * l.level) + await diff(l.level)) * await mxp(l.level)
expstr = f"{l.experience}/{req}"
if m is not None:
username = _removeNonAscii(m.name)
else:
username = "******"
lines.append(
f"{username.ljust(32)}{str(l.level).ljust(8)}{expstr.ljust(10)}"
)
msg = '\n'.join(lines)
codeblock = f"```{msg}```"
await client.send_message(message.channel, codeblock)
def test_get_healthy_server():
healthy_server = Server('localhost:8081')
unhealthy_server = Server('localhost:8082')
unhealthy_server.healthy = False
register = {
'www.mango.com': [healthy_server, unhealthy_server],
'www.apple.com': [healthy_server, healthy_server],
'www.orange.com': [unhealthy_server, unhealthy_server],
'/mango': [healthy_server, unhealthy_server],
'/apple': [unhealthy_server, unhealthy_server]
}
assert get_healthy_server('www.mango.com', register) == healthy_server
assert get_healthy_server('www.apple.com', register) == healthy_server
assert get_healthy_server('www.orange.com', register) is None
assert get_healthy_server('/mango', register) == healthy_server
assert get_healthy_server('/apple', register) is None
def redirect_to_server(self, route_name):
servers = Server.query_all().fetch(2)
if servers and len(servers) == 1:
self.redirect(
webapp2.uri_for(route_name, server_key=servers[0].url_key))
else:
self.redirect(webapp2.uri_for('main'))
def test_post_duplicate_none_port(self):
self.server.mc_properties.server_port = 25565
self.server.mc_properties.put()
self.log_in_admin()
self.mc = MinecraftDownload.create(
'1.7.4',
'https://s3.amazonaws.com/Minecraft.Download/versions/1.7.4/minecraft_server.1.7.4.jar'
)
self.server.version = self.mc.version
self.server.put()
response = self.post(
params={
'name': self.server.name,
'version': self.server.version,
'memory': '1G',
'server_port': '',
'idle_timeout': 10,
'eula_agree': True
})
self.assertEqual(1, Server.query().count())
self.assertEqual(1, Client.query().count())
server = self.server.key.get()
server = self.server.key.get()
self.assertIsNone(server.mc_properties.server_port)
self.assertRedirects(response,
'/servers/{0}'.format(server.key.urlsafe()))
def post(self):
try:
form = ServerPropertiesForm(formdata=self.request.POST)
if form.validate():
server = Server.create(
name=form.name.data,
is_gce=True,
version=form.version.data,
memory=form.memory.data,
operator=form.operator.data or None,
idle_timeout=form.idle_timeout.data
)
mc_properties = server.mc_properties
for prop in form:
if prop.name not in ['name', 'version', 'memory', 'operator', 'idle_timeout']:
if prop.type == 'IntegerField' or prop.name in [
'gamemode', 'difficulty', 'op_permission_level'
]:
if prop.data is not None:
setattr(mc_properties, prop.name, int(prop.data))
else:
setattr(mc_properties, prop.name, prop.data)
mc_properties.put()
if not set_form_short_name(server, form):
message = "Short name '{0}' is already assigned to another world".format(form.short_name.data)
self.session.add_flash(message, level='warn')
self.redirect(webapp2.uri_for('home', server_key=server.url_key))
except Exception, e:
logging.error(u"Error POSTing GCE server: {0}".format(e))
self.abort(404)
def server_search(to_visit_sites, start_point):
with session_scope() as session:
while len(to_visit_sites):
helper = to_visit_sites.pop(0)
response = requests.get(helper)
soup = BeautifulSoup(response.content, 'html.parser')
r = requests.head(helper)
server_info = r.headers.get("server")
if server_info is None:
server_info = "NO SERVER FOUND"
info = session.query(Server).filter(Server.name == helper).one_or_none()
if info is None:
ser = Server(name=helper, server=server_info)
session.add(ser)
session.commit()
for link in soup.find_all('a'):
to_be_added = link.get('href')
if to_be_added is not None and to_be_added not in to_visit_sites:
if to_be_added.startswith('http') and ".bg" in to_be_added:
to_visit_sites.append(to_be_added)
print(to_be_added)
elif to_be_added.startswith("link"):
to_be_added = start_point + to_be_added
to_visit_sites.append(to_be_added)
print(to_be_added)
async def on_message(self, message):
if isinstance(message.channel, discord.DMChannel
) or message.author.bot or message.content is None:
return
if session.query(Server).filter_by(
id=message.guild.id).first() is None:
s = Server(id=message.guild.id, prefix='?', roles=['off'])
session.add(s)
session.commit()
if session.query(User).filter_by(id=message.author.id).first() is None:
s = User(id=message.author.id, last_vote=0)
session.add(s)
session.commit()
try:
if await self.get_cmd(message):
session.commit()
except Exception as e:
traceback.print_exc()
await message.channel.send(
'Internal exception detected in command, {}'.format(e))
def get_home_redirect(handler, *args, **kwargs):
short_name = kwargs.get('short_name', None)
if not short_name:
return handler.uri_for('main')
server = Server.get_by_short_name(short_name)
if not server:
return handler.uri_for('main')
return handler.uri_for('home', server_key=server.short_name)
def server_parser_v1(self, json):
serverName, osSystem = json["server"], json["system"]
if serverName and osSystem:
if not Server.isdupe(serverName):
db.session.add(Server(ServerName=serverName, ServerOS=osSystem))
db.session.commit()
else:
pass
def communication(request):
import pdb
# pdb.set_trace()
print "start=====com"
if request.method != 'POST':
resp = JsonResponse({'type': 'login', 'source': 'host', 'ack_nak': 'NAK'})
resp['Access-Control-Allow-Origin'] = '*'
return resp
source = request.POST.get('source', '')
op = request.POST.get('type', 'login')
room = Room.objects.select_for_update().filter(numbers=source).first()
print "operator======, ", op
if op == 'login':
if not room:
user = User.objects.create(username=get_rand_name(), password='******')
room = Room.objects.create(user_id=user.id, numbers=source)
ip_port = request.POST.get('ip_port', None)
print "ip___port:_______ ", ip_port
room.ip_address = ip_port
room.host = Server.get_host()
room.link = 1
room.save()
print "========================="
resp = JsonResponse({'type':'login', 'source':'host', 'ack_nak': 'ACK'})
resp['Access-Control-Allow-Origin'] = '*'
return resp
if not room:
resp = JsonResponse({'type': op, 'source': 'host', 'ack_nak': 'NAK'})
resp['Access-Control-Allow-Origin'] = '*'
return resp
if op == 'logout':
room.link = 0
room.save()
resp = JsonResponse({'type':'logout', 'source':'host', 'ack_nak': 'ACK'})
resp['Access-Control-Allow-Origin'] = '*'
return resp
elif op == 'require':
speed = request.POST.get('speed', 'low')
print "start stop"
resp = post_to_client(room.ip_address, {'type':'stop', 'source': 'host'})
stop_cost(room.id, room.room_temperature)
room.speed = RESPEED[speed]
room.service = 0
room.save()
resp = JsonResponse({'type':'require', 'source':'host', 'ack_nak': 'ACK'})
resp['Access-Control-Allow-Origin'] = '*'
return resp
elif op == 'query_cost':
resp = JsonResponse({'type': 'query_cost', 'source': 'host', 'ack_nak': 'ACK', 'power_consumption': room.power,
'price': room.price, 'total_cost': room.total_cost})
resp['Access-Control-Allow-Origin'] = '*'
return resp
elif op == 'query_mode':
resp = JsonResponse({'type': 'query_mode', 'source': 'host', 'ack_nak': 'ACK', 'mode': MODE[Server.get_attr('mode')]})
resp['Access-Control-Allow-Origin'] = '*'
return resp
def get_template_context(self, context=None):
template_context = dict()
if context:
template_context.update(context)
template_context['flashes'] = self.session.get_flashes()
template_context['request'] = self.request
template_context['user'] = self.user
template_context['config'] = coal_config
template_context['server'] = Server.global_key().get()
return template_context
def get(self, tenant_id):
servers = [
{
'id': server.server_id,
'name': server.name,
'status': server.status,
}
for server in Server.select(Server.server_id, Server.name, Server.status).where(Server.tenant_id == tenant_id).order_by(Server.server_id)
]
self.write({'servers': servers})
def get(self):
results, previous_cursor, next_cursor = self.get_results_with_cursors(
User.query_all(), User.query_all_reverse(), RESULTS_PER_PAGE
)
servers = []
for server in Server.query():
servers.append(server)
instance = gce.Instance.singleton()
status = instance.get_status()
context = {'servers': servers, 'instance': instance, 'status': status}
self.render_template('admin.html', context=context)
def make_task(server_id, status):
sleep(10)
db.connect()
try:
server = Server.get(Server.server_id == server_id)
except Server.DoesNotExist:
db.close()
return False
server.status = status
server.save()
db.close()
return True
def delete(self, tenant_id, server_id):
try:
server = Server.get(Server.tenant_id == tenant_id, Server.server_id == server_id)
except Server.DoesNotExist:
self.write({'status': 'not_found'})
return
server.delete_instance()
self.write({
'id': int(server_id),
'status': 'deleted',
})
def post(self):
try:
form = ServerForm(formdata=self.request.POST)
if form.validate():
server = Server.create(name=form.name.data, is_gce=False)
if not set_form_short_name(server, form):
message = "Short name '{0}' is already assigned to another world".format(form.short_name.data)
self.session.add_flash(message, level='warn')
self.redirect(webapp2.uri_for('home', server_key=server.url_key))
except Exception, e:
logging.error(u"Error POSTing server: {0}".format(e))
self.abort(404)
def get(self, tenant_id, server_id):
try:
server = Server.get(Server.tenant_id == tenant_id, Server.server_id == server_id)
except Server.DoesNotExist:
self.write({'status': 'not_found'})
return
self.write({
'id': server.server_id,
'name': server.name,
'status': server.status,
'date_created': str(server.date_created),
})
def post(self, package_id):
data = self.request.json
for srvdict in data:
srvcpts = srvdict.pop("components")
query = self.db.query(Server).filter_by(host=srvdict["host"])
if query.count() == 0:
srv = Server(**srvdict)
self.db.add(srv)
else:
srv = query.one()
for key, value in srvdict.iteritems():
srv.__setattr__(key, value)
self.db.execute("DELETE FROM server_component \
WHERE server_id=:server_id \
AND component_id IN (SELECT id FROM component WHERE package_id=:package_id)",
{ "server_id": srv.id, "package_id": package_id} )
for dic in srvcpts:
component_id = self.db.query(Component.id).filter_by(package_id=package_id, name=dic["name"]).scalar()
self.db.add( ServerComponent(srv.id, component_id, dic["active"]) )
self.db.commit()
def test_list(self):
"""
list of servers
"""
clear_db()
s1 = Server.create(server_id=None, tenant_id=1, name="name1", status="ready")
s2 = Server.create(server_id=None, tenant_id=1, name="name2", status="scheduled")
Server.create(server_id=None, tenant_id=2, name="name3", status="ready")
request = HTTPRequest(
self.get_url("/1/servers/"), method="GET", headers=HTTPHeaders({"X-AUTH-TOKEN": X_AUTH_TOKEN})
)
self.http_client.fetch(request, self.stop)
response = self.wait()
message = json.loads(response.body)
assert message == {
"servers": [
{"status": s1.status, "id": s1.server_id, "name": s1.name},
{"status": s2.status, "id": s2.server_id, "name": s2.name},
]
}
def getServer(self):
serverdomain = self.request.get('serverdomain')
server_ssl = False
url = "http"
if self.request.get('ssl') == "True":
server_ssl = True
url += "s"
url += "://%s" % serverdomain
notifywithprowl = self.request.get('notifywithprowl')
notifywithemail = self.request.get('notifywithemail')
parser = self.request.get('parser')
parsermetadata = self.request.get('parsermetadata')
# Figure out the key.
keyvalue = "%s_%s_%s" % (url, parser, parsermetadata)
if notifywithprowl:
keyvalue += "_Y"
else:
keyvalue += "_N"
if notifywithemail:
keyvalue += "_Y"
else:
keyvalue += "_N"
server = Server(key_name=keyvalue)
server.url = url
server.serverdomain = serverdomain
server.ssl = server_ssl
if notifywithprowl == "True":
server.notifywithprowl = True
if notifywithemail == "True":
server.notifywithemail = True
#server.notifywithtwitter = self.request.get('notifywithtwitter')
server.parser = parser
server.parsermetadata = parsermetadata
server.email = users.get_current_user().email()
return server
def get_server_by_key(self, key, abort=True):
if key:
try:
server_key = ndb.Key(urlsafe=key)
server = server_key.get()
except Exception:
server = Server.get_by_short_name(key)
else:
server = None
if server is not None and not server.active:
server = None
if abort and not server:
self.abort(404)
self.request.server = server
return self.request.server
def __call__(self, form, field):
server = self.server or form.server
short_name = field.data
key = None
try:
key = ndb.Key(urlsafe=short_name)
except:
pass
if key is not None:
raise validators.ValidationError("Short name can't be a valid key string".format(short_name))
s = Server.get_by_short_name(short_name)
if s is not None:
if server is None or s.key != server.key:
raise validators.ValidationError(
"Short name '{0}' is already assigned to another server".format(short_name)
)
def create_or_update_server_repository(db_session, hostname, server_type, server_url, username, vrf,
server_directory, password, destination_on_host, created_by, server=None):
hostname = check_acceptable_string(hostname)
if server is None:
server = Server(created_by=created_by)
db_session.add(server)
server.hostname = hostname
server.server_type = server_type
server.server_url = server_url
server.username = username
server.password = password
server.vrf = vrf if (server_type == ServerType.TFTP_SERVER or
server_type == ServerType.FTP_SERVER) else ''
server.server_directory = server_directory
server.destination_on_host = destination_on_host if server_type == ServerType.SCP_SERVER else ''
db_session.commit()
return server
def test_delete(self):
"""
delete existing server
"""
clear_db()
s1 = Server.create(server_id=None, tenant_id=1, name="name1", status="ready")
request = HTTPRequest(
self.get_url("/1/servers/" + str(s1.server_id)),
method="DELETE",
headers=HTTPHeaders({"X-AUTH-TOKEN": X_AUTH_TOKEN}),
)
self.http_client.fetch(request, self.stop)
response = self.wait()
message = json.loads(response.body)
assert message == {"status": "deleted", "id": s1.server_id}
def get(self):
context = {'title': main_config.TITLE, 'description': main_config.DESCRIPTION}
user = self.user
if user:
if user.active:
servers = Server.query_all().fetch(100)
if servers and len(servers) == 1:
self.redirect(webapp2.uri_for('home', server_key=servers[0].url_key))
return
context = {
'servers': servers
}
self.render_template('main.html', context=context)
else:
form = UserEmailForm(obj=user)
context['form'] = form
self.render_template('main_inactive.html', context=context)
else:
self.render_template('main_unauth.html', context=context)
def post(self, tenant_id):
name = self.get_argument('name')
if not 20 >= len(name) >= 5:
self.write({'status': 'invalid_name'})
return
server = Server.create(
server_id=None,
tenant_id=tenant_id,
name=name,
)
IOLoop.current().spawn_callback(self.run_task, server.server_id)
self.write({
'id': server.server_id,
'name': server.name,
'status': server.status,
})
