def mysqldump(*databases, **long_kwds):
    output = long_kwds.pop("output", None)
    cmd = linux.build_cmd_args(executable="/usr/bin/mysqldump", long=long_kwds, params=databases)
    kwds = {}
    if output:
        kwds["stdout"] = open(output, "w+")
    return linux.system(cmd, **kwds)

 def args(self, *params, **long_kwds):
     self.cmd = linux.build_cmd_args(
         executable=self.executable,
         long=long_kwds,
         params=params)
     LOG.debug('cmd: %s', self.cmd)
     return self

def dd(**kwds):
    short = []
    for k, v in kwds.items():
        short.append('%s=%s' % (k, v))
    return linux.system(linux.build_cmd_args(
                executable='/bin/dd',
                short=short))

def innobackupex(*params, **long_kwds):
	if not os.path.exists('/usr/bin/innobackupex'):
		pkgmgr.installed('percona-xtrabackup')
	return linux.system(linux.build_cmd_args(
			executable='/usr/bin/innobackupex', 
			long=long_kwds, 
			params=params))

	def _gen_src(self):
		if self.file_per_database:
			for db_name in self._databases:
				self._current_db = db_name
				cmd = linux.build_cmd_args(
					executable='/usr/bin/mysqldump',
					params=__mysql__['mysqldump_options'].split() + [db_name])
				mysql_dump = subprocess.Popen(cmd, bufsize=-1, 
								stdout=subprocess.PIPE, stderr=subprocess.PIPE)
				yield mysql_dump.stdout
		else:
			cmd = linux.build_cmd_args(
				executable='/usr/bin/mysqldump',
				params=__mysql__['mysqldump_options'].split() + ['--all-databases'])
			mysql_dump = subprocess.Popen(cmd, bufsize=-1, 
							stdout=subprocess.PIPE, stderr=subprocess.PIPE)
			yield mysql_dump.stdout

	def mkfs(self, device, *short_args):
		short_args = list(short_args)
		short_args.extend(('-t', self.type))
		args = linux.build_cmd_args(
					executable='/sbin/mkfs', 
					short=short_args, 
					params=[device])
		system(args, error_text=self.error_messages['mkfs'] % device)

def modprobe(module_name, **long_kwds):
    if not os_info['mods_enabled']:
        return (None, None, 0)

    return linux.system(linux.build_cmd_args(
                executable='/sbin/modprobe', 
                long=long_kwds,
                params=[module_name]), 
            error_text='Kernel module %s is not available' % module_name)

def mysqldump(*databases, **long_kwds):
	output = long_kwds.pop('output', None)
	cmd = linux.build_cmd_args(
			executable='/usr/bin/mysqldump',
			long=long_kwds,
			params=databases)
	kwds = {}
	if output:
		kwds['stdout'] = open(output, 'w+')
	return linux.system(cmd, **kwds)

def rsync(src, dst, **long_kwds):
    if not os.path.exists('/usr/bin/rsync'):
        pkgmgr.installed('rsync')
    system(['sync'])
    output = system(build_cmd_args(executable='/usr/bin/rsync',
                                   long=long_kwds,
                                   params=[src, dst],
                                   duplicate_keys=True))
    system(['sync'])
    return output

def vgchange(*volume_group_names, **long_kwds):
	try:
		return linux.system(linux.build_cmd_args(
				executable='/sbin/vgchange',
				long=long_kwds,
				params=volume_group_names))
	except linux.LinuxError, e:
		if e.returncode == 5:
			raise NotFound()
		raise

def my_print_defaults(*option_groups):
    out = linux.system(linux.build_cmd_args(executable="/usr/bin/my_print_defaults", params=option_groups))[0]
    ret = {}
    for line in out.splitlines():
        cols = line.split("=")
        ret[cols[0][2:]] = cols[1] if len(cols) > 1 else True
    for key in __mysql__["defaults"]:
        if key not in ret:
            ret[key] = __mysql__["defaults"][key]
    return ret

def iptables(**long_kwds):

	ordered_long = OrderedDict()
	for key in ("protocol", "match"):
		if key in long_kwds:
			ordered_long[key] = long_kwds.pop(key)
	ordered_long.update(long_kwds)

	return linux.system(linux.build_cmd_args(executable=IPTABLES_BIN,
		long=ordered_long))

def pvchange(*physical_volume_paths, **long_kwds):
	try:
		return linux.system(linux.build_cmd_args(
				executable='/sbin/pvchange',
				long=long_kwds,
				params=physical_volume_paths))
	except linux.LinuxError, e:
		if e.returncode == 5:
			raise NotFound()
		raise

def lvcreate(*params, **long_kwds):
    try:
        return linux.system(linux.build_cmd_args(
                        executable='/sbin/lvcreate',
                        long=long_kwds,
                        params=params))
    finally:
        if linux.os['name'] == 'GCEL':
            # Logical volumes not available for mount immediately
            # Problem posted to Google at 29 Apr 2013.
            time.sleep(1)

def iptables_save(filename=None, *short_args, **long_kwds):
    # file name is a path string or file-like object
    # if filename is None return output
    kwds = {}
    if isinstance(filename, basestring):
        filename = open(filename, 'w+')
    if hasattr(filename, 'write'):
        kwds['stdout'] = filename
    out = linux.system(linux.build_cmd_args(executable=IPTABLES_SAVE,
            short=short_args, long=long_kwds), **kwds)[0]
    return out

def lvchange(*logical_volume_path, **long_kwds):
    try:
        long_kwds.update({'yes': True})
        return linux.system(linux.build_cmd_args(
                        executable='/sbin/lvchange',
                        long=long_kwds,
                        params=logical_volume_path))
    except linux.LinuxError, e:
        if 'not found' in str(e).lower():
            raise NotFound()
        raise

 def get_children(self):
     try:
         pgrep = linux.system(linux.build_cmd_args(
             executable="pgrep",
             short=["-P"],
             params=[str(self.pid)]))
     except linux.LinuxError:
         children = []
     else:
         children = map(int, pgrep[0].splitlines())
     return children

def vgremove(*volume_group_names, **long_kwds):
	try:
		long_kwds.update({'force': True})
		return linux.system(linux.build_cmd_args(
				executable='/sbin/vgremove',
				long=long_kwds,
				params=volume_group_names))
	except linux.LinuxError, e:
		if e.returncode == 5:
			raise NotFound()
		raise

def umount(device_or_mpoint, **long_kwds):
    args = linux.build_cmd_args(
            executable='/bin/umount',
            short=('-f', device_or_mpoint),
            long=long_kwds)
    try:
        linux.system(args, error_text='Cannot umount %s' % device_or_mpoint)
    except linux.LinuxError, e:
        if 'not mounted' in e.err or 'not found' in e.err:
            return
        raise

def lvremove(*logical_volume_paths, **long_kwds):
	try:
		long_kwds.update({'force': True})
		return linux.system(linux.build_cmd_args(
				executable='/sbin/lvremove',
				long=long_kwds,
				params=logical_volume_paths))
	except linux.LinuxError, e:
		if e.returncode == 5:
			raise NotFound()
		raise