def test_session_manager_can_set_active_customer(self): self.session_manager = SessionManager() self.session_manager.set_active_customer() self.assertTrue(self.session_manager.get_active_customer())
def initialize(self): self.publish_queue = [] self.options = options from models import engine, db_bootstrap self.db_session = scoped_session(sessionmaker(bind=engine)) db_bootstrap(self.db_session) from session_manager import SessionManager self.session_manager = SessionManager( timeout_limit=self.options.session_timeout_limit) self.context = zmq.Context() self.input_socket = self.context.socket(zmq.REP) self.input_socket.bind(self.options.trade_in) self.publisher_socket = self.context.socket(zmq.PUB) self.publisher_socket.bind(self.options.trade_pub) input_log_file_handler = logging.handlers.TimedRotatingFileHandler( self.options.trade_log, when='MIDNIGHT') formatter = logging.Formatter('%(asctime)s - %(message)s') input_log_file_handler.setFormatter(formatter) self.replay_logger = logging.getLogger("REPLAY") self.replay_logger.setLevel(logging.INFO) self.replay_logger.addHandler(input_log_file_handler) self.replay_logger.info('START') self.log_start_data()
def __init__(self, handlers=None, default_host=None, transforms=None, **settings): super(WSAplication, self).__init__(handlers, default_host, transforms, **settings) self.session_manager = SessionManager()
def loadSessionFromFile(self, fileName): sessionManager = SessionManager(self.app) file = open(fileName, "r") propertyDict = sessionManager.parseTextLines(file.readlines()) self.volumeViewer.loadSessionInfo(sessionManager, propertyDict) self.skeletonViewer.loadSessionInfo(sessionManager, propertyDict) self.sseViewer.loadSessionInfo(sessionManager, propertyDict) self.calphaViewer.loadSessionInfo(sessionManager, propertyDict) self.mainCamera.loadSessionInfo(sessionManager, propertyDict) file.close()
def saveSessionToFile(self, fileName): sessionManager = SessionManager(self.app) file = open(fileName, "w") textLines = [] textLines.extend(self.getSessionHeader(sessionManager)) textLines.extend(self.mainCamera.getSessionInfo(sessionManager)) textLines.extend(self.volumeViewer.getSessionInfo(sessionManager)) textLines.extend(self.skeletonViewer.getSessionInfo(sessionManager)) textLines.extend(self.sseViewer.getSessionInfo(sessionManager)) textLines.extend(self.calphaViewer.getSessionInfo(sessionManager)) file.writelines(textLines) file.close()
def __init__(self, config_, ioloop, *args, **kwargs): super().__init__(*args, **kwargs) self.ioloop = ioloop self.logger = logging.getLogger('servicehub') self.logger.setLevel(config.LOGLEVEL) self.session_manager = SessionManager() self.docker = aiodocker.Docker() image_config = config_['image'] self.image = image_config.get('name') self.image_label = image_config.get('label', 'latest') self.image_remove = image_config.getboolean('remove', False) self.session_lifetime = config_['session'].get('lifetime', 21600) self.remove_container = config_['session'].getboolean('remove', False)
def initialize(self, options, instance_name): self.publish_queue = [] self.options = options self.instance_name = instance_name self.order_matcher_disabled = False if options.has_option('order_matcher_disabled'): self.order_matcher_disabled = True from models import Base, db_bootstrap db_engine = options.sqlalchemy_engine + ':///' + \ os.path.expanduser(options.sqlalchemy_connection_string) engine = create_engine(db_engine, echo=options.db_echo) Base.metadata.create_all(engine) self.db_session = scoped_session(sessionmaker(bind=engine)) db_bootstrap(self.db_session) from session_manager import SessionManager self.session_manager = SessionManager( timeout_limit=self.options.session_timeout_limit) self.context = zmq.Context() self.input_socket = self.context.socket(zmq.REP) self.input_socket.bind(self.options.trade_in) self.publisher_socket = self.context.socket(zmq.PUB) self.publisher_socket.bind(self.options.trade_pub) input_log_file_handler = logging.handlers.TimedRotatingFileHandler( os.path.expanduser(self.options.trade_log), when='MIDNIGHT') input_log_file_handler.setFormatter( logging.Formatter('%(asctime)s - %(message)s')) self.replay_logger = logging.getLogger(self.instance_name) self.replay_logger.setLevel(logging.INFO) self.replay_logger.addHandler(input_log_file_handler) ch = logging.StreamHandler(sys.stdout) ch.setLevel(logging.DEBUG) ch.setFormatter( logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s')) self.replay_logger.addHandler(ch) self.replay_logger.info('START') self.log_start_data()
def main(): host = input('Hostname: ') port = input('Port: ') username = input('Username: '******'Password: '******'', username, password, ] with paramiko.SSHClient() as ssh: try: ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(host, port=int(port), username=username, password=password) except Exception as ex: print(ex) sys.exit(1) session = ssh.invoke_shell() dir_path = os.getcwd() + os.sep + time.strftime( '%Y-%m-%d_%H:%M') + '_output' if not os.path.exists(dir_path): os.mkdir(dir_path) csv_writer = CSVWriter( dir_path, ['HOSTNAME', 'TELNET', 'SSH', 'VERSION', 'SERIALNUMBER']) session_manager = SessionManager(session, auth_list, csv_writer, dir_path) try: with open('hostnames.txt') as file: hostnames = [hostname.rstrip('\n') for hostname in file] except Exception as ex: print(ex) sys.exit(1) with concurrent.futures.ThreadPoolExecutor() as executor: executor.map(session_manager.manage, hostnames) csv_writer.close()
def __init__(self): self.configDb = sqlite3.connect('../userdata.db') configDb = self.configDb configDb.row_factory = sqlite3.Row cursor = configDb.cursor() # Ensure settings table exists and create it if not cursor.execute( "SELECT name FROM sqlite_master WHERE Type='table' and name = 'settings'" ) if cursor.fetchone() is None: self.createSettingsTable() app = QtGui.QApplication(sys.argv) mainApplicationWindow = MainApplicationWindow(configDb) mainApplicationWindow.hide() sessionManager = SessionManager(mainApplicationWindow, configDb) # sessionManager.show() self.mainApplicationWindow = mainApplicationWindow self.sessionManager = sessionManager app.exec_()
def __init__(self, name, s_size, a_size, trainer, model_path, global_episodes, env_name, seed, test, cell_units, params, testing_trial=False): self.name = "worker_" + str(name) self.number = name self.model_path = model_path self.trainer = trainer self.global_episodes = global_episodes self.increment = self.global_episodes.assign_add(1) self.episode_rewards = [] self.episode_lengths = [] self.episode_mean_values = [] self.summary_writer = tf.summary.FileWriter("train_" + str(self.number)) self.is_test = test self.a_size = a_size self.params = params # Create the local copy of the network and the tensorflow op to copy global parameters to local network self.local_AC = AC_Network(s_size, a_size, cell_units, self.name, trainer) self.update_local_ops = update_target_graph('global', self.name) self.testing_trial = testing_trial if not self.testing_trial: self.scenario_name = params['train_scenario_name'] self.attempt_limit = params['train_attempt_limit'] else: self.scenario_name = params['test_scenario_name'] self.attempt_limit = params['test_attempt_limit'] self.scenario = select_scenario(self.scenario_name, params['use_physics']) env = gym.make(env_name) self.manager = SessionManager(env, params, human=False) self.manager.update_scenario(self.scenario) self.manager.env.reward_mode = params['reward_mode'] self.trial_count = 0 self.manager.env.seed(seed)
session.manager.broadcast("Someone left.") async def websocket(manager, request): session = manager.get(str(uuid.uuid4()), True) transport = WebSocketServerHLEB(manager, session, request) try: return await transport.process() except asyncio.CancelledError: raise except aiohttp.web.HTTPException as exc: return exc async def send_currenttime(manager): while True: manager.broadcast("Payload: " + str(datetime.datetime.now())) await asyncio.sleep(1) if __name__ == '__main__': app = aiohttp.web.Application() manager = SessionManager(app, chat_msg_handler, app.loop) app.router.add_get("/ws", lambda request: websocket(manager, request)) asyncio.ensure_future(send_currenttime(manager), loop=app.loop) aiohttp.web.run_app(app)
def main(_): global master_network global global_episodes reward_mode = None if len(sys.argv) < 2: # general params # training params # PICK ONE and comment others params = PARAMS['CE3-CE4'] # params = PARAMS['CE3-CC4'] # params = PARAMS['CC3-CE4'] # params = PARAMS['CC3-CC4'] # params = PARAMS['CE4'] # params = PARAMS['CC4'] else: setting = sys.argv[1] params = PARAMS[IDX_TO_PARAMS[int(setting) - 1]] print(('training_scenario: {}, testing_scenario: {}'.format( params['train_scenario_name'], params['test_scenario_name']))) reward_mode = sys.argv[2] use_physics = False num_training_iters = 100 # RL specific settings params['data_dir'] = '../../OpenLockA3CResults/subjects/' params['train_attempt_limit'] = 300 params['test_attempt_limit'] = 300 params['use_physics'] = False params['num_training_iters'] = 100 params['reward_mode'] = reward_mode scenario = select_scenario(params['train_scenario_name'], use_physics=use_physics) ENV_NAME = 'arm_lock-v0' env = gym.make(ENV_NAME) # create session/trial/experiment manager manager = SessionManager(env, params, human=False) manager.update_scenario(scenario) trial_selected = manager.run_trial_common_setup( scenario_name=params['train_scenario_name'], action_limit=params['train_action_limit'], attempt_limit=params['train_attempt_limit']) env.observation_space = ObservationSpace(len(scenario.levers)) MODEL_DIR = manager.writer.subject_path + '/models' MONITOR_DIR = manager.writer.subject_path + '/monitor' STATE_DIM = env.observation_space.shape ACTION_DIM = len(env.action_space) # delete temporary env env.close() tf.reset_default_graph() if not os.path.exists(MODEL_DIR): os.makedirs(MODEL_DIR) with tf.device("/cpu:0"): np.random.seed(RANDOM_SEED) tf.set_random_seed(RANDOM_SEED) global_episodes = tf.Variable(0, dtype=tf.int32, name='global_episodes', trainable=False) trainer = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE) master_network = AC_Network(STATE_DIM, ACTION_DIM, CELL_UNITS, 'global', None) # Generate global network num_workers = multiprocessing.cpu_count( ) # Set workers to number of available CPU threads # For testing and visualisation we only need one worker if TEST_MODEL: num_workers = 1 workers = [] # Create worker classes for i in range(num_workers): workers.append( Worker(name=i, s_size=STATE_DIM, a_size=ACTION_DIM, trainer=trainer, model_path=MODEL_DIR, global_episodes=global_episodes, env_name=ENV_NAME, seed=RANDOM_SEED, test=TEST_MODEL, cell_units=CELL_UNITS, params=params)) saver = tf.train.Saver(max_to_keep=5) # Gym monitor if not TEST_MODEL: env = workers[0].get_env() env = gym.wrappers.Monitor(env, MONITOR_DIR, video_callable=False, force=True) with tf.Session() as sess: coord = tf.train.Coordinator() if LOAD_MODEL or TEST_MODEL: print('Loading Model...') ckpt = tf.train.get_checkpoint_state(MODEL_DIR) saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) if TEST_MODEL: env = workers[0].get_env() env = gym.wrappers.Monitor(env, MONITOR_DIR, force=True) workers[0].work(GAMMA, sess, coord, saver) else: # This is where the asynchronous magic happens. # Start the "work" process for each worker in a separate thread. print('Launching workers...') worker_threads = [] for worker in workers: worker_work = lambda: worker.work(GAMMA, sess, coord, saver) t = threading.Thread(target=(worker_work)) t.start() worker_threads.append(t) coord.join(worker_threads)
from flask import Blueprint, render_template, abort from jinja2 import TemplateNotFound from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from database_setup import Base, Category, Item from session_manager import SessionManager db = SessionManager() categoryMenu_bp = Blueprint('categoryMenu', __name__, template_folder='templates') @categoryMenu_bp.route('/') @categoryMenu_bp.route('/category/<int:category_id>/') def categoryMenu(category_id): category = db.session.query(Category).filter_by(id=category_id).one() items = db.session.query(Item).filter_by(category_id=category.id) return render_template('menu.html', category=category, items=items)
sys.path.append(substrateDir) from session_manager import SessionManager parser = reqparse.RequestParser() parser.add_argument('name', type=str, required=True) parser.add_argument('amount', type=int, required=True) parser.add_argument('intensity', type=int, required=True) parser.add_argument('roastRightAway', type=bool, required=True) parser.add_argument('delayHours', type=int, required=True) parser.add_argument('delayMinutes', type=int, required=True) coffee_req_schema = CoffeeRequest.CoffeeRequest _sm = SessionManager() class Coffee(Resource): def get(self): return "Hello world" def post(request): args = parser.parse_args() roastAt = datetime.now() if not args.roastRightAway: roastAt = datetime.now() + timedelta(hours=args.delayHours, minutes=args.delayMinutes) req = coffee_req_schema(name=args.name, amount=args.amount, intensity=args.intensity, roastRightAway=args.roastRightAway, roastAt=roastAt) flask.g.session.add(req)
# as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. from session_manager import SessionManager sessionManager = SessionManager() def get_sessionManager(): return sessionManager def get_databus(): return sessionManager._databus def get_gridpot(): return sessionManager._gridpot def get_session(*args, **kwargs): return sessionManager.get_session(*args, **kwargs)
def __zoom_in(self): self._camera.zoom_in() def __zoom_out(self): self._camera.zoom_out() def __delete_cur_session(self): self._periodic_thread.cancel() shutil.rmtree(self._session_manager.current_session.session_path) self._session_manager.reset_cur_session() self._periodic_thread.start() def __show_frame(self, image_name): return self._camera.show_frame(image_name) def __show_next_frame(self): img_iter = self._session_manager.current_session.get_img_iterator() if img_iter: img = next(img_iter) if img: self.__show_frame(img) else: self.__show_frame('res/logo.jpg') if __name__ == '__main__': spasso1 = SpassoUno(SessionManager(), Camera(), PeriodicThread(period=1.5)) spasso1.run() spasso1.cleanup()
def setUp(self): self.__sessionManager = SessionManager()
def run_server(data_dir: str) -> None: ps = PhotoStore(data_dir) sm = SessionManager(data_dir) class RequestHandler(BaseHTTPRequestHandler): def send_cookie(self, c: BaseCookie) -> None: for key in c: self.send_header('Set-Cookie', c[key].output(header='')) def serve_static(self, path: str) -> None: path = os.path.normpath(path)[1:] if path == "": path = "photos.html" if "." not in path: path = path + ".html" path = os.path.join("../static/", path) print(path) if os.path.isfile(path): with open(path, "rb") as f: contents = f.read() self.send_response(200) mime, _ = mimetypes.guess_type(path) if mime is None: mime = "application/octet-stream" self.send_header('Content-type', mime) self.end_headers() self.wfile.write(contents) else: self.serve_404() def serve_text(self, text: str, status: int = 200) -> None: self.send_response(status) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write(bytes(text, "utf8")) def serve_json(self, value: Any, status: int = 200) -> None: js = json.dumps(value) self.send_response(status) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write(bytes(js, "utf8")) def serve_400(self) -> None: self.serve_text("Bad Request.", 400) def serve_404(self) -> None: self.serve_text("File not found.", 404) def get_cookies(self) -> Dict[str, str]: cookie_str = self.headers["Cookie"] if cookie_str is None: return {} return { key: value for key, value in [ cookie.split("=", 1) for cookie in str(cookie_str).split("; ") ] } def get_sess_id(self) -> Optional[str]: cookies = self.get_cookies() if "sess_id" in cookies: return cookies["sess_id"] else: return None def get_username(self) -> Optional[str]: sess_id = self.get_sess_id() if sess_id is not None: return sm.session_user(sess_id) else: return None def has_read_permission(self, list_name: str) -> bool: if list_name == 'all': return self.get_username() is not None else: return True def has_write_permission(self, list_name: str) -> bool: return self.get_username() is not None def do_GET(self) -> None: path = self.path.rsplit("?", 1)[0] spath = path.split("/") if len(spath) == 3 and spath[1] == "photo": hsh = spath[2] cm = ps.get_photo(hsh) if cm is not None: contents, mime = cm self.send_response(200) self.send_header('Content-type', mime) self.end_headers() self.wfile.write(contents) return elif len(spath) == 3 and spath[1] == "download": if "." in spath[2]: hsh = spath[2].rsplit(".", 1)[0] cm = ps.get_photo(hsh) if cm is not None: contents, mime = cm mime = "application/octet-stream" self.send_response(200) self.send_header('Content-type', mime) self.end_headers() self.wfile.write(contents) return else: hsh = spath[2] ext = ps.get_photo_extension(hsh) self.send_response(301) self.send_header('Location', '/download/%s%s' % (hsh, ext)) self.end_headers() return elif len(spath) == 3 and spath[1] == 'thumb': hsh = spath[2] cm = ps.get_thumbnail(hsh) if cm is not None: contents, mime = cm self.send_response(200) self.send_header("Content-type", mime) self.end_headers() self.wfile.write(contents) return elif len(spath) == 3 and spath[1] == "list": list_name = urllib.parse.unquote(spath[2]) if self.has_read_permission(list_name): self.serve_json(ps.get_list(list_name)) else: self.serve_json([]) return elif len(spath) == 2 and spath[1] == "albums": self.serve_json(ps.get_albums()) return elif len(spath) == 2 and spath[1] == 'username': self.serve_json(self.get_username()) return elif len(spath) == 2 and spath[1] == 'logout': sess_id = self.get_sess_id() if sess_id is not None: sm.end_session(sess_id) self.serve_json(None) return self.serve_static(path) def do_POST(self) -> None: path = self.path.rsplit("?", 1)[0] length_header = self.headers['Content-Length'] if length_header is None: length = 0 else: length = int(str(length_header)) try: post_data = json.loads(self.rfile.read(length).decode('utf-8')) except json.JSONDecodeError: self.serve_400() return if path == "/download": try: hashes = post_data['hashes'] except KeyError: self.serve_400() return content, mime = ps.get_photos_tgz(hashes) self.send_response(200) self.send_header('Content-type', mime) self.end_headers() self.wfile.write(content) return elif path == "/add": try: album_name = post_data['album'] hashes = post_data['hashes'] except KeyError: self.serve_400() return if self.has_write_permission(album_name): ps.add_photos_to_album(hashes, album_name) self.send_response(201) self.end_headers() self.wfile.write(bytes("true", encoding="utf-8")) else: self.send_response(403) self.end_headers() self.wfile.write(bytes("false", encoding="utf-8")) return elif path == "/remove": try: album_name = post_data['album'] hashes = post_data['hashes'] except KeyError: self.serve_400() return if self.has_write_permission(album_name): ps.remove_photos_from_album(hashes, album_name) self.send_response(201) self.end_headers() self.wfile.write(bytes("true", encoding="utf-8")) else: self.send_response(403) self.end_headers() self.wfile.write(bytes("false", encoding="utf-8")) return elif path == "/login": try: username = post_data['username'] password = post_data['password'] except KeyError: self.serve_400() return cookie = sm.login(username, password) if cookie is not None: self.send_response(200) self.send_cookie(cookie) self.end_headers() self.wfile.write(bytes(username, encoding="utf-8")) else: self.serve_text("Invalid username or password", 401) return elif path == "/passwordChange": try: old_password = post_data['oldPassword'] new_password = post_data['newPassword'] except KeyError: self.serve_400() return username = self.get_username() if username is None: self.serve_400() return if sm.authenticate(username, old_password): sm.set_password(username, new_password) self.send_response(200) self.end_headers() self.wfile.write(bytes()) else: self.serve_text("Invalid password", 401) return # Server settings # Choose port 8080, for port 80, which is normally used for a http server, you need root access server_address = ('127.0.0.1', 8081) httpd = HTTPServer(server_address, RequestHandler) httpd.serve_forever()