258 lines
9.7 KiB
Python
Executable File
258 lines
9.7 KiB
Python
Executable File
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
gcp: Goffi's CoPier
|
|
Copyright (C) 2010 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
### logging ###
|
|
import logging
|
|
from logging import debug, info, error, warning
|
|
logging.basicConfig(level=logging.DEBUG,
|
|
format='%(message)s')
|
|
###
|
|
import sys
|
|
import os,os.path
|
|
from optparse import OptionParser #To be replaced by argparse ASAP
|
|
import cPickle as pickle
|
|
try:
|
|
import gobject
|
|
#DBus
|
|
import dbus, dbus.glib
|
|
import dbus.service
|
|
import dbus.mainloop.glib
|
|
except ImportError,e:
|
|
error("Error during import")
|
|
error("Please check dependecies:",e)
|
|
exit(2)
|
|
try:
|
|
from progressbar import ProgressBar, Percentage, Bar, ETA, FileTransferSpeed
|
|
pbar_available=True
|
|
except ImportError, e:
|
|
info ('ProgressBar not available, please download it at http://pypi.python.org/pypi/progressbar')
|
|
info ('Progress bar deactivated\n--\n')
|
|
pbar_available=False
|
|
|
|
NAME = "gcp (Goffi's copier)"
|
|
NAME_SHORT = "gcp"
|
|
VERSION = '0.1'
|
|
|
|
ABOUT = NAME+" v"+VERSION+""" (c) Jérôme Poisson (aka Goffi) 2010
|
|
|
|
---
|
|
"""+NAME+""" Copyright (C) 2010 Jérôme Poisson
|
|
This program comes with ABSOLUTELY NO WARRANTY;
|
|
This is free software, and you are welcome to redistribute it
|
|
under certain conditions.
|
|
---
|
|
|
|
This software is an advanced file copier
|
|
Get the latest version at http://www.goffi.org
|
|
"""
|
|
|
|
const_DBUS_INTERFACE = "org.goffi.gcp"
|
|
const_DBUS_PATH = "/org/goffi/gcp"
|
|
|
|
|
|
class DbusObject(dbus.service.Object):
|
|
|
|
def __init__(self, gcp, bus, path):
|
|
self._gcp = gcp
|
|
dbus.service.Object.__init__(self, bus, path)
|
|
debug("Init DbusObject...")
|
|
self.cb={}
|
|
|
|
@dbus.service.method(const_DBUS_INTERFACE,
|
|
in_signature='', out_signature='s')
|
|
def getVersion(self):
|
|
"""Get gcp version
|
|
@return: version as string"""
|
|
return VERSION
|
|
|
|
@dbus.service.method(const_DBUS_INTERFACE,
|
|
in_signature='ss', out_signature='bs')
|
|
def addArgs(self, source_path, args):
|
|
"""Add arguments to gcp as if there were entered on its own command line
|
|
@param source_path: current working dir to use as base for arguments, as given by os.getcwd()
|
|
@param args: serialized (wich pickle) list of strings - without command name -, as given by sys.argv[1:].
|
|
@return: success (boolean) and error message if any (string)"""
|
|
try:
|
|
args = pickle.loads(str(args))
|
|
except TypeError, pickle.UnpicklingError:
|
|
return (False, "INTERNAL ERROR: invalid arguments")
|
|
return self._gcp.parseArguments(args, source_path)
|
|
|
|
class GCP():
|
|
|
|
def __init__(self):
|
|
try:
|
|
sessions_bus = dbus.SessionBus()
|
|
db_object = sessions_bus.get_object(const_DBUS_INTERFACE,
|
|
const_DBUS_PATH)
|
|
self.gcp_main = dbus.Interface(db_object,
|
|
dbus_interface=const_DBUS_INTERFACE)
|
|
self._main_instance = False
|
|
|
|
except dbus.exceptions.DBusException,e:
|
|
if e._dbus_error_name=='org.freedesktop.DBus.Error.ServiceUnknown':
|
|
self.launchDbusMainInstance()
|
|
debug ("gcp launched")
|
|
self._main_instance = True
|
|
else:
|
|
raise e
|
|
|
|
def launchDbusMainInstance(self):
|
|
debug ("Init DBus...")
|
|
session_bus = dbus.SessionBus()
|
|
self.dbus_name = dbus.service.BusName(const_DBUS_INTERFACE, session_bus)
|
|
self.dbus_object = DbusObject(self, session_bus, const_DBUS_PATH)
|
|
|
|
self.copy_list = []
|
|
self.mounts = self.__getMountPoints()
|
|
self.files_left = 0
|
|
self.bytes_left = 0
|
|
|
|
def getFsType(self, path):
|
|
fs=''
|
|
for mount in self.mounts:
|
|
if path.startswith(mount) and len(self.mounts[mount])>=len(fs):
|
|
fs = self.mounts[mount]
|
|
return fs
|
|
|
|
def __getMountPoints(self):
|
|
"""Parse /proc/mounts to get currently mounted devices"""
|
|
#TODO: reparse when a new device is added/a device is removed
|
|
#(check freedesktop mounting signals)
|
|
ret = {}
|
|
try:
|
|
with open("/proc/mounts",'r') as mounts:
|
|
for line in mounts.readlines():
|
|
fs_spec, fs_file, fs_vfstype, fs_mntops, fs_freq, fs_passno = line.split(' ')
|
|
ret[fs_file] = fs_vfstype
|
|
except:
|
|
error ("Can't read mounts table")
|
|
return ret
|
|
|
|
def __appendToList(self, path, destpath, options):
|
|
"""Add a file to the copy list
|
|
@param path: absolute path of file
|
|
@param options: options as return by optparse"""
|
|
debug ("Adding to copy list: %s ==> %s (%s)", path, destpath, self.getFsType(destpath))
|
|
try:
|
|
self.bytes_left+=os.path.getsize(path)
|
|
self.files_left+=1
|
|
self.copy_list.append((path, destpath, options))
|
|
print "total size:", float(self.bytes_left/1024/1024), "Mb (%i)" % self.files_left
|
|
except OSError,e:
|
|
error("Can't copy %(path)s: %(exception)s" % {'path':path, 'exception':e.strerror})
|
|
|
|
|
|
def __appendDirToList(self, dirpath, destpath, options):
|
|
"""Add recursively directory to the copy list
|
|
@param path: absolute path of dir
|
|
@param options: options as return by optparse"""
|
|
try:
|
|
for filename in os.listdir(dirpath):
|
|
filepath = os.path.join(dirpath,filename)
|
|
if os.path.isdir(filepath):
|
|
full_destpath = os.path.join(destpath,filename)
|
|
self.__appendDirToList(filepath, full_destpath, options)
|
|
else:
|
|
self.__appendToList(filepath, destpath, options)
|
|
except OSError,e:
|
|
error("Can't copy %(path)s: %(exception)s" % {'path':dirpath, 'exception':e.strerror})
|
|
|
|
def __checkArgs(self, options, source_path, args):
|
|
"""Check thats args are files, and add them to copy list"""
|
|
assert(len (args)>=2)
|
|
try:
|
|
destpath = os.path.normpath(os.path.join(os.path.expanduser(source_path), args.pop()))
|
|
except OSError,e:
|
|
error ("Invalid destpath: %s",e)
|
|
|
|
for path in args:
|
|
abspath = os.path.normpath(os.path.join(os.path.expanduser(source_path), path))
|
|
if not os.path.exists(abspath):
|
|
warning("The path given in arg doesn't exist or is not accessible: %s",abspath)
|
|
else:
|
|
if os.path.isdir(abspath):
|
|
full_destpath = destpath if os.path.isabs(path) else os.path.normpath(os.path.join(destpath, path))
|
|
if not options.recursive:
|
|
warning ('omitting directory "%s"' % abspath)
|
|
else:
|
|
self.__appendDirToList(abspath, full_destpath, options)
|
|
else:
|
|
self.__appendToList(abspath, destpath, options)
|
|
|
|
|
|
def parseArguments(self, full_args=sys.argv[1:], source_path = os.getcwd()):
|
|
"""Parse arguments and add files to queue
|
|
@param full_args: list of arguments strings (without program name)
|
|
@param source_path: path from where the arguments come, ad given by os.getcwd()
|
|
@return: a tuple (boolean, message) where the boolean is the success of the arguments
|
|
validation, and message is the error message to print when necessary"""
|
|
_usage="""
|
|
%prog [options] FILE1 [FILE2 ...] DEST
|
|
|
|
%prog --help for options list
|
|
"""
|
|
for idx in range(len(full_args)):
|
|
if isinstance(full_args[idx], unicode):
|
|
#We don't want unicode as some filenames can be invalid unicode
|
|
full_args[idx] = full_args[idx].encode('utf-8')
|
|
|
|
parser = OptionParser(usage=_usage,version=ABOUT)
|
|
|
|
parser.add_option("-r", "--recursive", action="store_true", default=False,
|
|
help="copy directories recursively")
|
|
|
|
parser.add_option("--no-unicode-fix", action="store_true", default=False,
|
|
help="don't fixe name encoding errors") #TODO
|
|
(options, args) = parser.parse_args(full_args)
|
|
|
|
if not self._main_instance:
|
|
info ("There is already one instance of %s running, pluging to it" % NAME_SHORT)
|
|
#XXX: we have to serialize data as dbus only accept valid unicode, and filenames
|
|
# can have invalid unicode.
|
|
return self.gcp_main.addArgs(os.getcwd(),pickle.dumps(full_args))
|
|
else:
|
|
if len(args) < 2:
|
|
_error_msg = "Wrong number of arguments"
|
|
return (False, _error_msg)
|
|
debug("adding args to gcp: %s",args)
|
|
self.__checkArgs(options, source_path, args)
|
|
return (True,'')
|
|
|
|
def go(self):
|
|
"""Launch main loop"""
|
|
self.loop = gobject.MainLoop()
|
|
try:
|
|
self.loop.run()
|
|
except KeyboardInterrupt:
|
|
info("User interruption: good bye")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
gcp = GCP()
|
|
success,message = gcp.parseArguments()
|
|
if not success:
|
|
error(message)
|
|
exit(1)
|
|
if gcp._main_instance:
|
|
gcp.go()
|
|
|