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_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 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, })