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()
