Exemplo n.º 1
0
def get_config_files():
    """ return the path to the config files or and empty list.
    The search path is based on the paths returned by load_config_paths
    but it's returned in reverse order (e.g: /etc/xdg first).
    """
    config_files = []
    for xdg_config_dir in load_config_paths("ubuntuone"):
        xdg_config_dir = native_path(xdg_config_dir)
        config_file = os.path.join(xdg_config_dir, CONFIG_FILE)
        if os.path.exists(config_file):
            config_files.append(config_file)

        config_logs = os.path.join(xdg_config_dir, CONFIG_LOGS)
        if os.path.exists(config_logs):
            config_files.append(config_logs)

    # reverse the list as load_config_paths returns the user dir first
    config_files.reverse()
    # if we are running from a branch, get the config files from it too
    config_file = os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir, "data", CONFIG_FILE)
    if os.path.exists(config_file):
        config_files.append(config_file)

    config_logs = os.path.join("data", CONFIG_LOGS)
    if os.path.exists(config_logs):
        config_files.append(config_logs)

    return config_files
Exemplo n.º 2
0
    def __init__(self, root_dir, shares_dir, data_dir, partials_dir,
                 host='fs-1.one.ubuntu.com', port=443, dns_srv=None, ssl=True,
                 disable_ssl_verify=False,
                 mark_interval=120, broadcast_events=False,
                 handshake_timeout=30,
                 shares_symlink_name='Shared With Me',
                 read_limit=None, write_limit=None, throttling_enabled=False,
                 ignore_files=None, oauth_credentials=None):
        self.root_dir = root_dir
        self.shares_dir = shares_dir
        self.shares_dir_link = os.path.join(self.root_dir, shares_symlink_name)
        self.data_dir = data_dir
        self.partials_dir = partials_dir
        tritcask_dir = os.path.join(self.data_dir, 'tritcask')
        self.logger = logging.getLogger('ubuntuone.SyncDaemon.Main')
        user_config = config.get_user_config()
        if read_limit is None:
            read_limit = user_config.get_throttling_read_limit()
        if write_limit is None:
            write_limit = user_config.get_throttling_write_limit()
        if not throttling_enabled:
            throttling_enabled = user_config.get_throttling()

        self.logger.info("Starting Ubuntu One client version %s",
                         clientdefs.VERSION)
        self.logger.info("Using %r as root dir", self.root_dir)
        self.logger.info("Using %r as data dir", self.data_dir)
        self.logger.info("Using %r as shares root dir", self.shares_dir)
        self.db = tritcask.Tritcask(native_path(tritcask_dir))
        self.vm = volume_manager.VolumeManager(self)
        self.fs = filesystem_manager.FileSystemManager(
            data_dir, partials_dir, self.vm, self.db)
        self.event_q = event_queue.EventQueue(self.fs, ignore_files)
        self.fs.register_eq(self.event_q)

        # subscribe VM to EQ, to be unsubscribed in shutdown
        self.event_q.subscribe(self.vm)
        self.vm.init_root()

        # we don't have the oauth tokens yet, we 'll get them later
        self.action_q = action_queue.ActionQueue(self.event_q, self,
                                                 host, port,
                                                 dns_srv, ssl,
                                                 disable_ssl_verify,
                                                 read_limit, write_limit,
                                                 throttling_enabled)
        self.hash_q = hash_queue.HashQueue(self.event_q)
        events_nanny.DownloadFinishedNanny(self.fs, self.event_q, self.hash_q)

        # call StateManager after having AQ
        self.state_manager = StateManager(self, handshake_timeout)

        self.sync = sync.Sync(self)
        self.lr = local_rescan.LocalRescan(self.vm, self.fs,
                                           self.event_q, self.action_q)

        self.external = SyncdaemonService(main=self,
                                          send_events=broadcast_events)
        self.external.oauth_credentials = oauth_credentials
        if user_config.get_autoconnect():
            self.external.connect(autoconnecting=True)

        self.eventlog_listener = None
        self.start_event_logger()

        self.status_listener = None
        self.start_status_listener()

        self.mark = task.LoopingCall(self.log_mark)
        self.mark.start(mark_interval)
Exemplo n.º 3
0
    del new_tcp
# end of naming shenanigans

CONFIG_FILE = "syncdaemon.conf"
CONFIG_LOGS = "logging.conf"

# sections
THROTTLING = "bandwidth_throttling"
NOTIFICATIONS = "notifications"
MAIN = "__main__"

# global logger
logger = logging.getLogger("ubuntuone.SyncDaemon.config")

# get (and possibly create if don't exists) the user config file
_user_config_path = os.path.join(native_path(save_config_path("ubuntuone")), CONFIG_FILE)

# module private config instance.
# this object is the shared config
_user_config = None

path_from_unix = lambda path: path.replace("/", os.path.sep)


def home_dir_parser(value):
    """Parser for the root_dir and shares_dir options.

    Return the path using user home + value.

    """
    path = path_from_unix(value)
Exemplo n.º 4
0
# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
#
# In addition, as a special exception, the copyright holders give
# permission to link the code of portions of this program with the
# OpenSSL library under certain conditions as described in each
# individual source file, and distribute linked combinations
# including the two.
# You must obey the GNU General Public License in all respects
# for all of the code used other than OpenSSL.  If you modify
# file(s) with this exception, you may extend this exception to your
# version of the file(s), but you are not obligated to do so.  If you
# do not wish to do so, delete this exception statement from your
# version.  If you delete this exception statement from all source
# files in the program, then also delete it here.
"""Defines a constant for ubuntuone's log folder based on XDG."""

import os

from ubuntu_sso.xdg_base_directory import xdg_cache_home, native_path

# All usage of the ubuntuone_log_dir is for native access,
# so we only change it here
ubuntuone_log_dir = os.path.join(xdg_cache_home, 'ubuntuone', 'log')
ubuntuone_log_dir = native_path(ubuntuone_log_dir)
if not os.path.exists(ubuntuone_log_dir):
    os.makedirs(ubuntuone_log_dir)