def action_create(self):
    group = self.group
    if not group:
      command = ['groupadd']
      Logger.info("Adding group %s" % self.resource)
    else:
      command = ['groupmod']
      
      for option_name, attributes in self.options.iteritems():
        if getattr(self.resource, option_name) != None and getattr(self.resource, option_name) != attributes[0](self):
          break
      else:
        return
      
      Logger.info("Modifying group %s" % (self.resource.group_name))

    for option_name, attributes in self.options.iteritems():
      option_value = getattr(self.resource, option_name)
      if attributes[1] and option_value:
        command += [attributes[1], str(option_value)]
        
    command.append(self.resource.group_name)

    # if trying to modify existing group, but no values to modify are provided
    if self.group and len(command) == 1:
      return
    
    shell.checked_call(command, sudo=True)

def read_file(filename):
  tmpf = tempfile.NamedTemporaryFile()
  shell.checked_call(["cp", "-f", filename, tmpf.name], sudo=True)
  
  with tmpf:
    with open(tmpf.name, "rb") as fp:
      return fp.read()

 def action_run(self):
   if self.resource.creates:
     if sudo.path_exists(self.resource.creates):
       Logger.info("Skipping %s due to creates" % self.resource)
       return
     
   env = self.resource.environment
         
   for i in range (0, self.resource.tries):
     try:
       shell.checked_call(self.resource.command, logoutput=self.resource.logoutput,
                           cwd=self.resource.cwd, env=env,
                           preexec_fn=_preexec_fn(self.resource), user=self.resource.user,
                           wait_for_finish=self.resource.wait_for_finish,
                           timeout=self.resource.timeout,
                           path=self.resource.path,
                           sudo=self.resource.sudo,
                           on_new_line=self.resource.on_new_line)
       break
     except Fail as ex:
       if i == self.resource.tries-1: # last try
         raise ex
       else:
         Logger.info("Retrying after %d seconds. Reason: %s" % (self.resource.try_sleep, str(ex)))
         time.sleep(self.resource.try_sleep)
     except ExecuteTimeoutException:
       err_msg = ("Execution of '%s' was killed due timeout after %d seconds") % (self.resource.command, self.resource.timeout)
       
       if self.resource.on_timeout:
         Logger.info("Executing '%s'. Reason: %s" % (self.resource.on_timeout, err_msg))
         shell.checked_call(self.resource.on_timeout)
       else:
         raise Fail(err_msg)

  def action_run(self):
    if self.resource.creates:
      if os.path.exists(self.resource.creates):
        return

    Logger.debug("Executing %s" % self.resource)
    
    if self.resource.path != []:
      if not self.resource.environment:
        self.resource.environment = {}
      
      self.resource.environment['PATH'] = os.pathsep.join(self.resource.path) 
    
    for i in range (0, self.resource.tries):
      try:
        shell.checked_call(self.resource.command, logoutput=self.resource.logoutput,
                            cwd=self.resource.cwd, env=self.resource.environment,
                            preexec_fn=_preexec_fn(self.resource), user=self.resource.user,
                            wait_for_finish=self.resource.wait_for_finish, timeout=self.resource.timeout,
                            pid_file=self.resource.pid_file, poll_after=self.resource.poll_after)
        break
      except Fail as ex:
        if i == self.resource.tries-1: # last try
          raise ex
        else:
          Logger.info("Retrying after %d seconds. Reason: %s" % (self.resource.try_sleep, str(ex)))
          time.sleep(self.resource.try_sleep)
      except ExecuteTimeoutException:
        err_msg = ("Execution of '%s' was killed due timeout after %d seconds") % (self.resource.command, self.resource.timeout)
        
        if self.resource.on_timeout:
          Logger.info("Executing '%s'. Reason: %s" % (self.resource.on_timeout, err_msg))
          shell.checked_call(self.resource.on_timeout)
        else:
          raise Fail(err_msg)

  def action_create(self):
    if not self.user:
      command = ['useradd', "-m"]
      Logger.info("Adding user %s" % self.resource)
    else:
      command = ['usermod']
      Logger.info("Modifying user %s" % (self.resource.username))

    options = dict(
      comment="-c",
      gid="-g",
      uid="-u",
      shell="-s",
      password="-p",
      home="-d",
    )

    if self.resource.system and not self.user:
      command.append("--system")

    if self.resource.groups:
      command += ["-G", ",".join(self.resource.groups)]

    for option_name, option_flag in options.items():
      option_value = getattr(self.resource, option_name)
      if option_flag and option_value:
        command += [option_flag, str(option_value)]

    command.append(self.resource.username)

    shell.checked_call(command)

  def action_run(self):
    if self.resource.creates:
      if os.path.exists(self.resource.creates):
        return

    Logger.debug("Executing %s" % self.resource)
    
    if self.resource.path != []:
      if not self.resource.environment:
        self.resource.environment = {}
      
      self.resource.environment['PATH'] = os.pathsep.join(self.resource.path) 
    
    for i in range (0, self.resource.tries):
      try:
        shell.checked_call(self.resource.command, logoutput=self.resource.logoutput,
                            cwd=self.resource.cwd, env=self.resource.environment,
                            preexec_fn=_preexec_fn(self.resource), user=self.resource.user,
                            wait_for_finish=self.resource.wait_for_finish)
        break
      except Fail as ex:
        if i == self.resource.tries-1: # last try
          raise ex
        else:
          Logger.info("Retrying after %d seconds. Reason: %s" % (self.resource.try_sleep, str(ex)))
          time.sleep(self.resource.try_sleep)

 def remove_package(self, name):
   if self._check_existence(name):
     cmd = REMOVE_CMD[self.get_logoutput()] + [name]
     Logger.info("Removing package %s ('%s')" % (name, string_cmd_from_args_list(cmd)))
     shell.checked_call(cmd, sudo=True, logoutput=self.get_logoutput())
   else:
     Logger.info("Skipping removal of non-existing package %s" % (name))

 def remove_package(self, name):
   if self._check_existence(name):
     cmd = REMOVE_CMD % (name)
     Logger.info("Removing package %s ('%s')" % (name, cmd))
     shell.checked_call(cmd)
   else:
     Logger.info("Skipping removing non-existent package %s" % (name))

 def install_package(self, name):
   if not self._check_existence(name):
     cmd = INSTALL_CMD % (name)
     Logger.info("Installing package %s ('%s')" % (name, cmd))
     shell.checked_call(cmd)
   else:
     Logger.info("Skipping installing existent package %s" % (name))

def select(stack_name, package, version, try_create=True, ignore_errors=False):
  """
  Selects a config version for the specified package. If this detects that
  the stack supports configuration versioning but /etc/<component>/conf is a
  directory, then it will attempt to bootstrap the conf.backup directory and change
  /etc/<component>/conf into a symlink.

  :param stack_name: the name of the stack
  :param package: the name of the package, as-used by <conf-selector-tool>
  :param version: the version number to create
  :param try_create: optional argument to attempt to create the directory before setting it
  :param ignore_errors: optional argument to ignore any error and simply log a warning
  """
  try:
    # do nothing if the stack does not support versioned configurations
    if not _valid(stack_name, package, version):
      return

    if try_create:
      create(stack_name, package, version)

    shell.checked_call(_get_cmd("set-conf-dir", package, version), logoutput=False, quiet=False, sudo=True)

    # for consistency sake, we must ensure that the /etc/<component>/conf symlink exists and
    # points to <stack-root>/current/<component>/conf - this is because some people still prefer to
    # use /etc/<component>/conf even though <stack-root> is the "future"
    package_dirs = get_package_dirs()
    if package in package_dirs:
      Logger.info("Ensuring that {0} has the correct symlink structure".format(package))

      directory_list = package_dirs[package]
      for directory_structure in directory_list:
        conf_dir = directory_structure["conf_dir"]
        current_dir = directory_structure["current_dir"]

        # if /etc/<component>/conf is missing or is not a symlink
        if not os.path.islink(conf_dir):
          # if /etc/<component>/conf is not a link and it exists, convert it to a symlink
          if os.path.exists(conf_dir):
            parent_directory = os.path.dirname(conf_dir)
            conf_backup_dir = os.path.join(parent_directory, "conf.backup")

            # create conf.backup and copy files to it (if it doesn't exist)
            Execute(("cp", "-R", "-p", conf_dir, conf_backup_dir),
              not_if = format("test -e {conf_backup_dir}"), sudo = True)

            # delete the old /etc/<component>/conf directory and link to the backup
            Directory(conf_dir, action="delete")
            Link(conf_dir, to = conf_backup_dir)
          else:
            # missing entirely
            # /etc/<component>/conf -> <stack-root>/current/<component>/conf
            Link(conf_dir, to = current_dir)

  except Exception, exception:
    if ignore_errors is True:
      Logger.warning("Could not select the directory for package {0}. Error: {1}".format(package,
        str(exception)))
    else:
      raise

  def action_create(self):
    with Environment.get_instance_copy() as env:
      repo_file_name = self.resource.repo_file_name
      repo_dir = get_repo_dir()
      new_content = InlineTemplate(self.resource.repo_template, repo_id=self.resource.repo_id, repo_file_name=self.resource.repo_file_name,
                             base_url=self.resource.base_url, mirror_list=self.resource.mirror_list)
      repo_file_path = format("{repo_dir}/{repo_file_name}.repo")

      if os.path.isfile(repo_file_path):
        existing_content_str = sudo.read_file(repo_file_path)
        new_content_str = new_content.get_content()
        if existing_content_str != new_content_str and OSCheck.is_suse_family():
          # We need to reset package manager's cache when we replace base urls
          # at existing repo. That is a case at least under SLES
          Logger.info("Flushing package manager cache since repo file content is about to change")
          checked_call(self.update_cmd, sudo=True)
        if self.resource.append_to_file:
          content = existing_content_str + '\n' + new_content_str
        else:
          content = new_content_str
      else: # If repo file does not exist yet
        content = new_content

      File(repo_file_path,
           content=content
      )

def chmod_recursive(path, recursive_mode_flags, recursion_follow_links):
  find_flags = []
  if recursion_follow_links:
    find_flags.append('-L')
    
  for key, flags in recursive_mode_flags.iteritems():
    shell.checked_call(["find"] + find_flags + [path, "-type", key, "-exec" , "chmod", flags ,"{}" ,";"])

 def chown_recursive(path, owner, group, follow_links=False):
   owner = owner.pw_name if owner else ""
   group = group.gr_name if group else ""
   if owner or group:
     flags = ["-R"]
     if follow_links:
       flags.append("-L")
     shell.checked_call(["chown"] + flags + [owner+":"+group, path], sudo=True)

 def action_install(self):
   package_name = self.resource.package_name
   location = self.resource.location
   if not self._check_existence(package_name, location):
     cmd = TAR_CMD % (package_name, location)
     if package_name.lower().endswith("zip"):
       cmd = ZIP_CMD % (package_name, location)
     Logger.info("Installing tarball %s at %s (%s)" % (package_name, location, cmd))
     shell.checked_call(cmd)

 def read_file(filename, encoding=None):
   tmpf = tempfile.NamedTemporaryFile()
   shell.checked_call(["cp", "-f", filename, tmpf.name], sudo=True)
   
   with tmpf:
     with open(tmpf.name, "rb") as fp:
       content = fp.read()
       
   content = content.decode(encoding) if encoding else content
   return content

 def install_package(self, name, use_repos=[]):
     if not self._check_existence(name) or use_repos:
         cmd = INSTALL_CMD[self.get_logoutput()]
         if use_repos:
             enable_repo_option = "--enablerepo=" + ",".join(use_repos)
             cmd = cmd + ["--disablerepo=*", enable_repo_option]
         cmd = cmd + [name]
         Logger.info("Installing package %s ('%s')" % (name, string_cmd_from_args_list(cmd)))
         shell.checked_call(cmd, sudo=True, logoutput=self.get_logoutput())
     else:
         Logger.info("Skipping installing existent package %s" % (name))

  def create_file(filename, content, encoding=None):
    """
    if content is None, create empty file
    """
    content = content if content else ""
    content = content.encode(encoding) if encoding else content

    tmpf_name = tempfile.gettempdir() + os.sep + tempfile.template + str(time.time()) + "_" + str(random.randint(0, 1000))
    try:
        with open(tmpf_name, "wb") as fp:
            fp.write(content)
        shell.checked_call(["cp", "-f", tmpf_name, filename], sudo=True)
    finally:
        os.unlink(tmpf_name)

def create_file(filename, content):
  """
  if content is None, create empty file
  """
  tmpf = tempfile.NamedTemporaryFile()
  
  if content:
    with open(tmpf.name, "wb") as fp:
      fp.write(content)
  
  with tmpf:    
    shell.checked_call(["cp", "-f", tmpf.name, filename], sudo=True)
    
  # set default files mode
  chmod(filename, 0644)

 def listdir(path):
   if not path_isdir(path):
     raise Fail("{0} is not a directory. Cannot list files of it.".format(path))
   
   code, out, err = shell.checked_call(["ls", path], sudo=True, stderr=subprocess.PIPE)
   files = out.splitlines()
   return files

 def action_run(self):
   if self.resource.creates:
     if sudo.path_exists(self.resource.creates):
       Logger.info("Skipping %s due to creates" % self.resource)
       return
     
   shell.checked_call(self.resource.command, logoutput=self.resource.logoutput,
                       cwd=self.resource.cwd, env=self.resource.environment,
                       preexec_fn=_preexec_fn(self.resource), user=self.resource.user,
                       wait_for_finish=self.resource.wait_for_finish,
                       timeout=self.resource.timeout,on_timeout=self.resource.on_timeout,
                       path=self.resource.path,
                       sudo=self.resource.sudo,
                       on_new_line=self.resource.on_new_line,
                       stdout=self.resource.stdout,stderr=self.resource.stderr,
                       tries=self.resource.tries, try_sleep=self.resource.try_sleep)