import os
import requests
import sysconfig
from openport.common.session import Session
from openport.services.logger_service import get_logger
from openport.services import osinteraction
from openport.common.config import DEFAULT_SERVER
logger = get_logger(__name__)
USER_CONFIG_FILE = '/etc/openport/users.conf'
if sysconfig.get_config_var('ANDROID_API_LEVEL') != [None]:
prefix = sysconfig.get_config_var('prefix')
USER_CONFIG_FILE = prefix + '/etc/openport/users.conf'
class AppService(object):
def __init__(self, openport_app_config):
self.config = openport_app_config
self.os_interaction = osinteraction.getInstance()
def set_manager_port(self, command):
os_interaction = osinteraction.getInstance()
if self.config.manager_port_from_config_file:
command = os_interaction.unset_variable(command, '--listener-port')
elif self.config.manager_port > 0:
command = os_interaction.set_variable(command, '--listener-port',
self.config.manager_port)
return command
def start_openport_process(self, port):
import sys
from time import sleep
import os
import threading
import requests
from bottle import Bottle, ServerAdapter, request, response, error, hook
from openport.services.logger_service import get_logger
from openport.services.utils import run_method_with_timeout
logger = get_logger('server')
class CherryPyServer(ServerAdapter):
def run(self, handler):
try:
from cheroot.wsgi import Server as CherryPyWSGIServer
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer
self.server = CherryPyWSGIServer((self.host, self.port), handler)
try:
self.server.start()
finally:
self.server.stop()
def stop(self):
if hasattr(self, 'server'):
self.server.stop()
from openport.services import osinteraction, dbhandler
from openport.services.logger_service import get_logger, set_log_level
from openport.common.config import OpenportAppConfig
from openport.common.session import Session
from openport.services import key_registration_service
from openport.services.config_service import ConfigService
from openport.services.app_service import AppService, USER_CONFIG_FILE
from openport.apps.openport_service import Openport
from openport.apps import openport_app_version
from openport.apps.app_tcp_server import AppTcpServer, send_exit, send_ping, is_running
from openport.apps.keyhandling import ensure_keys_exist, get_default_key_locations
from openport.common.config import DEFAULT_SERVER
logger = get_logger('openport_app')
from time import sleep
class OpenportApp(object):
def __init__(self):
self.config = OpenportAppConfig()
self.config.app = self
self.manager_app_started = False
self.os_interaction = osinteraction.getInstance()
self.args = {}
self.session = None
self.openport = Openport()
self.db_handler = None
self.server = AppTcpServer('127.0.0.1',
def __init__(self, use_logger=True):
if use_logger:
from openport.services.logger_service import get_logger
self.logger = get_logger('OsInteraction')
self.output_queues = {}
self.all_output = {}
import os
from time import sleep
import errno
from openport.apps import openport_api
from openport.apps.keyhandling import get_default_key_locations
from openport.common.config import DEFAULT_SERVER
from openport.apps.portforwarding import PortForwardingService, TunnelError
from openport.services.logger_service import get_logger
logger = get_logger('openport')
SERVER_SSH_PORT = 22
FALLBACK_SERVER_SSH_PORT = 443
FALLBACK_SSH_SERVER = 's.openport.io'
SERVER_SSH_USER = '******'
class Openport(object):
def __init__(self):
self.port_forwarding_service = None
self.restart_on_failure = True
self.session = None
self.automatic_restart = False
self.repeat_message = True
self.first_time_showing_message = True
self.last_response = None
self.stopped = False
def start_port_forward(self, session, server=DEFAULT_SERVER):
import os
import pickle
import logging
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Boolean
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import scoped_session
from sqlalchemy.orm.exc import NoResultFound
from openport.common.session import Session
from openport.services.logger_service import get_logger
from openport.services import osinteraction, migration_service
logger = get_logger('dbhandler')
# Configures the logging for SQLAlchemy
sqlalchemy_logger = get_logger('sqlalchemy')
for handler in sqlalchemy_logger.handlers:
handler.setLevel(logging.WARN)
Base = declarative_base()
class OpenportSession(Base):
__tablename__ = 'sessions'
id = Column(Integer, primary_key=True)
server = Column(String(50))