def set_log_level(level):
    if level not in [logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL]:
        logger.setLevel(logging.INFO)
    else:
        d1 = db.read_single_row("%s/integral_view_config.db" % db_path, "select * from global_params")
        cmd_list = []
        if d1:
            cmd = ["update global_params set logging_level=? where id = ?", (level, 1)]
        else:
            cmd = ["insert into global_params (logging_level, id) values(?,?)", (level, 1)]
        cmd_list.append(cmd)
        db.execute_iud("%s/integral_view_config.db" % db_path, cmd_list)
        logger.setLevel(level)
Esempio n. 2
0
def save_email_settings(d):

    conn = None
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        d1, err = db.read_single_row(db_path, "select * from email_config")
        if err:
            raise Exception(err)
        if d1:
            #Config exists so update
            ret, err = db.execute_iud(db_path, [[
                "update email_config set server=?, port=?, username=?, pswd=?, tls=?, email_alerts=?, email_audit=?, email_quota=?, rcpt_list=? where id = ?",
                (
                    d["server"],
                    d["port"],
                    d["username"],
                    d["pswd"],
                    d["tls"],
                    d["email_alerts"],
                    d["email_audit"],
                    d["email_quota"],
                    d["rcpt_list"],
                    1,
                )
            ]])
            if err:
                raise Exception(err)

        else:
            #No config exists so insert
            ret, err = db.execute_iud(db_path, [[
                "insert into email_config (server, port, username, pswd, tls, email_alerts,email_audit,email_quota, rcpt_list, id) values (?,?,?,?,?,?,?,?,?,?)",
                (
                    d["server"],
                    d["port"],
                    d["username"],
                    d["pswd"],
                    d["tls"],
                    d["email_alerts"],
                    d["email_audit"],
                    d["email_quota"],
                    d["rcpt_list"],
                    1,
                )
            ]])
            if err:
                raise Exception(err)
    except Exception, e:
        return False, 'Error saving email settings : %s' % str(e)
def get_log_level():
    d = None
    conn = None
    try:
        d = db.read_single_row("%s/integral_view_config.db" % db_path, "select * from global_params where id=1")
        if d and "logging_level" in d:
            return d["logging_level"]
        else:
            # Not yet set so insert the default and return it
            cmd_list = []
            cmd = ["insert into global_params (logging_level, id) values(?,?)", (logging.INFO, 1)]
            cmd_list.append(cmd)
            db.execute_iud("%s/integral_view_config.db" % db_path, cmd_list)
            return logging.INFO
    except Exception, e:
        print "Error inserting log level : %s" % str(e)
def refresh_alerts(request, random=None):
  try:
    from datetime import datetime
    cmd_list = []
    #this command will insert or update the row value if the row with the user exists.
    cmd = ["INSERT OR REPLACE INTO admin_alerts (user, last_refresh_time) values (?,?);", (request.user.username, datetime.now())]
    cmd_list.append(cmd)
    db_path, err = common.get_db_path()
    if err:
      raise Exception(err)
    test, err = db.execute_iud("%s/integral_view_config.db"%db_path, cmd_list)
    if err:
      raise Exception(err)
    new_alerts_present, err = alerts.new_alerts()
    if err:
      raise Exception(err)
    if new_alerts_present:
      import json
      alerts_list, err = alerts.load_alerts()
      if err:
        raise Exception(err)
      if not alerts_list:
        raise Exception('Error loading alerts')
      new_alerts = json.dumps([dict(alert=pn) for pn in alerts_list])
      return django.http.HttpResponse(new_alerts, mimetype='application/json')
    else:
      clss = "btn btn-default btn-sm"
      message = "View alerts"
      return django.http.HttpResponse("No New Alerts")
  except Exception, e:
    return django.http.HttpResponse("Error loading alerts : %s"%str(e))
def remove_cron(cron_task_id, user='******'):
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)

        tasks, err = get_tasks_by_cron_task_id(cron_task_id)
        if err:
            raise Exception(err)
        cmd_list = []
        cmd_list.append(
            ['delete from cron_tasks where cron_task_id=%d' % cron_task_id])
        cmd_list.append([
            'update tasks set status="cancelled" where cron_task_id=%s and status is not "completed"'
            % cron_task_id
        ])
        if tasks:
            for task in tasks:
                cmd_list.append([
                    'update subtasks set status="cancelled" where task_id=%d  and status is not "completed"'
                    % task['task_id']
                ])
        #print cmd_list

        ret, err = db.execute_iud(db_path, cmd_list)
        if err:
            raise Exception(err)

        cron = crontab.CronTab(user)
        cron.remove_all(comment=str(cron_task_id))
        cron.write()
    except Exception, e:
        return False, "Error deleting cron entry : %s" % str(e)
Esempio n. 6
0
def get_log_level():
    d = None
    conn = None
    log_level = None
    try:
        d, err = db.read_single_row(db_path,
                                    "select * from global_params where id=1")
        if err:
            raise Exception(err)
        if d and "logging_level" in d:
            log_level = d["logging_level"]
        else:
            #Not yet set so insert the default and return it
            cmd_list = []
            cmd = [
                "insert into global_params (logging_level, id) values(?,?)",
                (
                    logging.INFO,
                    1,
                )
            ]
            cmd_list.append(cmd)
            ret, err = db.execute_iud(db_path, cmd_list)
            if err:
                raise Exception(err)
            log_level = logging.INFO
    except Exception, e:
        return None, "Error getting log level : %s" % str(e)
Esempio n. 7
0
def refresh_alerts(request, random=None):
  try:
    from datetime import datetime
    cmd_list = []
    #this command will insert or update the row value if the row with the user exists.
    cmd = ["INSERT OR REPLACE INTO admin_alerts (user, last_refresh_time) values (?,?);", (request.user.username, datetime.now())]
    cmd_list.append(cmd)
    db_path, err = common.get_db_path()
    if err:
      raise Exception(err)
    test, err = db.execute_iud(db_path, cmd_list)
    if err:
      raise Exception(err)
    new_alerts_present, err = alerts.new_alerts()
    if err:
      raise Exception(err)
    if new_alerts_present:
      import json
      alerts_list, err = alerts.load_alerts(last_n = 5)
      if err:
        raise Exception(err)
      if not alerts_list:
        raise Exception('Error loading alerts')
      new_alerts = json.dumps([dict(alert=pn) for pn in alerts_list])
      return django.http.HttpResponse(new_alerts, content_type='application/json')
    else:
      clss = "btn btn-default btn-sm"
      message = "View alerts"
      return django.http.HttpResponse("No New Alerts")
  except Exception, e:
    return django.http.HttpResponse("Error loading alerts : %s"%str(e))
Esempio n. 8
0
def save_auth_settings(d):

    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd = [
            "update samba_global_common set workgroup=?, netbios_name=?, security=?, include_homes_section=? where id = ?",
            (
                d["workgroup"],
                d["netbios_name"],
                d["security"],
                True,
                1,
            )
        ]
        cmd_list = []
        cmd_list.append(cmd)
        if d["security"] == "ads":
            d1, err = db.read_single_row(db_path,
                                         "select * from samba_global_ad")
            if err:
                raise Exception(err)
            if d1:
                cmd = [
                    "update samba_global_ad set realm=?, password_server=?, ad_schema_mode=?, id_map_min=?, id_map_max=?, password_server_ip=?  where id = ?",
                    (
                        d["realm"],
                        d["password_server"],
                        'rfc2307',
                        16777216,
                        33554431,
                        d["password_server_ip"],
                        1,
                    )
                ]
                cmd_list.append(cmd)
            else:
                cmd = [
                    "insert into samba_global_ad (realm, password_server, ad_schema_mode, id_map_min, id_map_max, password_server_ip, id) values(?,?,?,?,?,?,?)",
                    (
                        d["realm"],
                        d["password_server"],
                        'rfc2307',
                        16777216,
                        33554431,
                        d["password_server_ip"],
                        1,
                    )
                ]
                cmd_list.append(cmd)
        #print cmd_list
        ret, err = db.execute_iud(db_path, cmd_list)
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error saving authentication settings : %s' % str(e)
Esempio n. 9
0
def delete_auth_settings():
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        ret, err = db.execute_iud(db_path, [["delete from samba_auth "]])
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error deleting authentication settings : %s' % str(e)
Esempio n. 10
0
def delete_email_settings():
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        ret, err = db.execute_iud(["delete from  email_config "])
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error deleting email settings : %s' % str(e)
Esempio n. 11
0
def delete_all_shares():
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd_list = []
        cmd_list.append(["delete from samba_shares "])
        cmd_list.append(["delete from samba_valid_users "])
        ret, err = db.execute_iud(db_path, cmd_list)
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error deleting all CIFS shares : %s' % str(e)
Esempio n. 12
0
def delete_remote_replication(remote_replication_id):
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd = "delete from remote_replications where remote_replication_id='%s'" % remote_replication_id
        rowid, err = db.execute_iud(db_path, [
            [cmd],
        ], get_rowid=False)
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error deleting remote replication task : %s' % e
Esempio n. 13
0
def update_remote_replication(remote_replication_id, new_cron_task_id):
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd = "update remote_replications set cron_task_id='%d' where remote_replication_id='%s'" % (
            new_cron_task_id, remote_replication_id)
        rowid, err = db.execute_iud(db_path, [
            [cmd],
        ], get_rowid=True)
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error updating  remote replication task : %s' % e
def remove_task(task_id):
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd_list = [['delete from tasks where task_id = %s' % task_id],
                    ['delete from subtasks where task_id = %s' % task_id]]
        #print cmd_list

        status, err = db.execute_iud(db_path, cmd_list)
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error removing task : %s' % e
Esempio n. 15
0
def refresh_alerts(request, random=None):
    from datetime import datetime
    cmd_list = []
    #this command will insert or update the row value if the row with the user exists.
    cmd = ["INSERT OR REPLACE INTO admin_alerts (user, last_refresh_time) values (?,?);", (request.user.username, datetime.now())]
    cmd_list.append(cmd)
    test = db.execute_iud("%s/integral_view_config.db"%common.get_db_path(), cmd_list)
    if alerts.new_alerts():
      import json
      new_alerts = json.dumps([dict(alert=pn) for pn in alerts.load_alerts()])
      return django.http.HttpResponse(new_alerts, mimetype='application/json')
    else:
      clss = "btn btn-default btn-sm"
      message = "View alerts"
      return django.http.HttpResponse("No New Alerts")
Esempio n. 16
0
def delete_share(share_id):

    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd_list = []
        cmd_list.append(
            ["delete from samba_shares where share_id=?", (share_id, )])
        cmd_list.append(
            ["delete from samba_valid_users where share_id=?", (share_id, )])
        ret, err = db.execute_iud(db_path, cmd_list)
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error deleting CIFS share : %s' % str(e)
def add_cron_task(command,
                  description,
                  min="1",
                  hour='*',
                  day='*',
                  dow='*',
                  month='*',
                  user='******'):
    cron_task_id = None
    try:
        if not command or not description:
            raise Exception('Invalid parameters')

        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)

    #cmd = ["insert into samba_global_ad (realm, password_server, ad_schema_mode, id_map_min, id_map_max, password_server_ip, id) values(?,?,?,?,?,?,?)", (d["realm"], d["password_server"], 'rfc2307', 16777216, 33554431, d["password_server_ip"], 1,)]
        cmd = [
            'insert into cron_tasks(command,description) values (?,?)',
            (command, description)
        ]
        #print cmd
        cron_task_id, err = db.execute_iud(db_path, [cmd], get_rowid=True)
        if err:
            raise Exception(err)

        log_path, err = common.get_log_folder_path()
        if err:
            raise Exception(err)
        log_dir = '%s/cron_logs' % log_path
        if not os.path.isdir(log_dir):
            os.mkdir(log_dir)
        log_file = '%s/%d.log' % (log_dir, cron_task_id)
        command = '%s >> %s 2>&1' % (command, log_file)

        cron = crontab.CronTab(user)
        job = cron.new(command=command, comment='%d' % cron_task_id)
        job.setall(min, hour, day, dow, month)
        if job.is_valid():
            job.enable()
            cron.write()
        else:
            raise Exception('Cron entry not valid.')

    except Exception, e:
        return None, 'Error creating cron entry : %s' % str(e)
Esempio n. 18
0
def save_share(share_id, name, comment, guest_ok, read_only, path, browseable,
               users, groups):

    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd_list = []
        cmd_list.append([
            "update samba_shares set comment=?, read_only=?, guest_ok=?, browseable=? where share_id=?",
            (
                comment,
                read_only,
                guest_ok,
                browseable,
                share_id,
            )
        ])
        cmd_list.append(
            ["delete from samba_valid_users where share_id=?", (share_id, )])
        if not guest_ok:
            if users:
                for user in users:
                    cmd_list.append([
                        "insert into samba_valid_users (id, share_id, grp, name) values (NULL,?,?,?)",
                        (
                            share_id,
                            False,
                            user,
                        )
                    ])
            if groups:
                for group in groups:
                    cmd_list.append([
                        "insert into samba_valid_users (id, share_id, grp, name) values (NULL,?,?,?)",
                        (
                            share_id,
                            True,
                            group,
                        )
                    ])
        ret, err = db.execute_iud(db_path, cmd_list)
        if err:
            raise Exception(err)

    except Exception, e:
        return False, 'Error saving CIFS share : %s' % str(e)
Esempio n. 19
0
def change_auth_method(security):

    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cl = []
        cl.append([
            "update samba_global_common set security='%s' where id=1" %
            security
        ])
        cl.append(["delete from samba_valid_users"])
        ret, err = db.execute_iud(db_path, cl)
        if err:
            raise Exception(err)
    except Exception, e:
        return False, 'Error changing authentication method : %s' % str(e)
Esempio n. 20
0
def add_remote_replication(source_dataset, destination_ip,
                           destination_username, destination_pool,
                           cron_task_id):
    remote_replication_id = None
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        cmd = "insert into remote_replications (source_dataset,destination_ip,destination_user_name,destination_pool, cron_task_id) values ('%s','%s','%s','%s', '%d')" % (
            source_dataset, destination_ip, destination_username,
            destination_pool, cron_task_id)
        remote_replication_id, err = db.execute_iud(db_path, [
            [cmd],
        ],
                                                    get_rowid=True)
        if err:
            raise Exception(err)
    except Exception, e:
        return None, 'Error adding a remote replication task : %s' % e
Esempio n. 21
0
def set_log_level(level):
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        if level not in [
                logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR,
                logging.CRITICAL
        ]:
            logger.setLevel(logging.INFO)
        else:
            d1, err = db.read_single_row(db_path,
                                         "select * from global_params")
            if err:
                raise Exception(err)
            cmd_list = []
            if d1:
                cmd = [
                    "update global_params set logging_level=? where id = ?",
                    (
                        level,
                        1,
                    )
                ]
            else:
                cmd = [
                    "insert into global_params (logging_level, id) values(?,?)",
                    (
                        level,
                        1,
                    )
                ]
            cmd_list.append(cmd)
            ret, err = db.execute_iud(db_path, cmd_list)
            if err:
                raise Exception(err)
            logger.setLevel(level)
    except Exception, e:
        return False, 'Error setting log level : %s' % str(e)
def set_log_level(level):
  try:
    db_path, err = common.get_db_path()
    if err:
      raise Exception(err)
    if level not in [logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL]:
      logger.setLevel(logging.INFO)
    else:
      d1, err = db.read_single_row("%s/integral_view_config.db"%db_path, "select * from global_params")
      if err:
        raise Exception(err)
      cmd_list = []
      if d1:
        cmd = ["update global_params set logging_level=? where id = ?", (level, 1,)]
      else:
        cmd = ["insert into global_params (logging_level, id) values(?,?)", (level, 1,)]
      cmd_list.append(cmd)
      ret, err = db.execute_iud("%s/integral_view_config.db"%db_path, cmd_list)
      if err:
        raise Exception(err)
      logger.setLevel(level)
  except Exception, e:
    return False, 'Error setting log level : %s'%str(e)
    d1 = db.read_single_row("%s/integral_view_config.db"%db_path, "select * from samba_global_ad")
    if d1:
      #cmd = ["update samba_global_ad set realm=?, password_server=?, ad_schema_mode=?, id_map_min=?, id_map_max=?  where id = ?", (d["realm"], d["password_server"], d["ad_schema_mode"], d["id_map_min"], d["id_map_max"], 1,)]
      cmd = ["update samba_global_ad set realm=?, password_server=?, ad_schema_mode=?, id_map_min=?, id_map_max=?, password_server_ip=?  where id = ?", (d["realm"], d["password_server"], 'rfc2307', 16777216, 33554431, d["password_server_ip"], 1, )]
      cmd_list.append(cmd)
    else:
      #cmd = ["insert into samba_global_ad (realm, password_server, ad_schema_mode, id_map_min, id_map_max, id) values(?,?,?,?,?,?)", (d["realm"], d["password_server"], d["ad_schema_mode"], d["id_map_min"], d["id_map_max"], 1,)]
      cmd = ["insert into samba_global_ad (realm, password_server, ad_schema_mode, id_map_min, id_map_max, password_server_ip, id) values(?,?,?,?,?,?,?)", (d["realm"], d["password_server"], 'rfc2307', 16777216, 33554431, d["password_server_ip"], 1,)]
      cmd_list.append(cmd)
  #print cmd_list
  #Always try to create the fractalio_guest account for guest access - will fail if it exists so ok
  try:
    local_users.create_local_user('fractalio_guest', 'Fractalio_Guest_User', 'fractalioguest')
  except Exception, e:
    pass
  db.execute_iud("%s/integral_view_config.db"%db_path, cmd_list)

def delete_auth_settings():
  conn = None
  try :
    conn = sqlite3.connect("%s/integral_view_config.db"%db_path)
    cur = conn.cursor()
    cur.execute("delete from samba_auth ")
    cur.close()
    conn.commit()
  finally:
    if conn:
      conn.close()

def load_shares_list():
  l = []
def add_task(description,
             subtask_list,
             task_type_id=0,
             cron_task_id=0,
             node=socket.getfqdn(),
             initiate_time=None,
             attempts=3,
             run_as_user_name='root',
             retry_interval=1):
    '''
  TODO 
    - change function name to add_task
    - take a scheduled_task_id parameter, defaulting to -1
    - change db parameters to new table
  '''
    row_id = -1
    try:
        if not description or not subtask_list:
            raise Exception("Insufficient parameters")

        now = int(time.time())
        if not initiate_time:
            initiate_time = now

        log_path, err = common.get_log_folder_path()
        if err:
            raise Exception(err)
        log_dir = '%s/task_logs' % log_path
        if not os.path.isdir(log_dir):
            os.mkdir(log_dir)

        cmd = "insert into tasks (description,task_type_id, node, run_as_user_name, attempts, cron_task_id, retry_interval, create_time, initiate_time) VALUES ('%s','%d','%s','%s','%d','%d','%d', '%d', '%d');" % (
            description, task_type_id, node, run_as_user_name, attempts,
            int(cron_task_id), retry_interval, now, initiate_time)
        #print cmd
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)

        row_id, err = db.execute_iud(db_path, [
            [cmd],
        ], get_rowid=True)
        #print "\n check!"
        if err:
            raise Exception(err)

        if row_id:
            log_file = '%s/%d.log' % (log_dir, row_id)
            for subtask in subtask_list:
                for description, command in subtask.iteritems():
                    command = '%s  &> %s' % (command, log_file)
                    cmd = "insert into subtasks (description,command,task_id) values ('%s','%s','%d');" % (
                        description, command, row_id)
                    status, err = db.execute_iud(db_path, [
                        [cmd],
                    ],
                                                 get_rowid=True)
                    if err:
                        raise Exception(
                            'Error creating scheduled command : %s' % err)
        else:
            raise Exception('Error creating scheduled task')
    except Exception, e:
        return False, ' Error adding task: %s' % e
def process_tasks(node=socket.getfqdn()):
    try:

        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)

        current_user = getpass.getuser()
        now = int(time.time())

        tasks_query = "select * from tasks where node == '" + node + "' and (status == 'error-retrying' or status == 'queued') and (initiate_time <= '%d');" % (
            now)
        print tasks_query
        tasks_to_process, err = db.read_multiple_rows(db_path, tasks_query)
        if err:
            raise Exception(err)
        print tasks_to_process

        if tasks_to_process is not None:

            for task in tasks_to_process:
                #print 'Processing task ', task['task_id']

                if task['last_run_time']:
                    seconds_since_last_run = (now - task['last_run_time'])
                    #retry_interval is in minutes!
                    if seconds_since_last_run < task['retry_interval'] * 60:
                        continue

                #Mark the task as running
                cmd = "update tasks set status = 'running', last_run_time=%d where task_id = '%d'" % (
                    now, task['task_id'])
                status, err = db.execute_iud(db_path, [
                    [cmd],
                ],
                                             get_rowid=True)
                #print status, err
                if err:
                    raise Exception(err)

                audit_str = "%s" % task['description']
                audit.audit("task_start",
                            audit_str,
                            None,
                            system_initiated=True)

                attempts = task['attempts']
                run_as_user_name = task['run_as_user_name']

                #Now process subtasks for the task
                subtasks_query = "select * from subtasks where task_id == '%d' and (status == 'error-retrying' or status == 'queued') order by subtask_id" % task[
                    'task_id']
                subtasks, err = db.read_multiple_rows(db_path, subtasks_query)
                if err:
                    raise Exception(err)

                #Assume task is complete unless proven otherwise
                task_completed = True

                # Iteriate through all the unfinished subtasks related to the task
                for subtask in subtasks:
                    #print 'subtask is ', subtask

                    subtask_id = subtask["subtask_id"]

                    status_update = "update subtasks set status = 'running' where subtask_id = '%d' and status is not 'cancelled'" % subtask_id
                    status, err = db.execute_iud(db_path, [
                        [status_update],
                    ],
                                                 get_rowid=True)
                    if err:
                        task_completed = False
                        break
                    #print subtask['command']
                    #print 'username is ', task['run_as_user_name']

                    #Now actually execute the command
                    #print 'not current user'
                    #This task is not to be meant to be executed by the current user so switch to that user
                    #print 'command is ', row['command']
                    (out, return_code), err = command.execute_with_rc(
                        subtask["command"],
                        shell=True,
                        run_as_user_name=run_as_user_name)
                    #print out, return_code, err

                    if out[0]:
                        output = re.sub("'", "", ''.join(out[0]))
                    else:
                        output = None
                    if out[1]:
                        error = re.sub("'", "", ''.join(out[1]))
                    else:
                        error = None

                    if return_code == 0:
                        # This means the command was successful. So update to completed
                        status_update = "update subtasks set status = 'completed', return_code='%d' where subtask_id = '%d' and status is not 'cancelled';" % (
                            return_code, subtask_id)
                        status, err = db.execute_iud(db_path, [
                            [status_update],
                        ],
                                                     get_rowid=True)
                        if err:
                            task_completed = False
                            break
                        else:
                            continue
                    else:
                        # Subtask command failed
                        if attempts > 1 or attempts == -2:
                            status_update = 'update subtasks set status = "error-retrying", return_code="%d" where subtask_id = "%d" and status is not "cancelled";' % (
                                return_code, subtask_id)
                        elif attempts in [0, 1]:
                            status_update = 'update scheduler_commands set status = "failed", return_code="%d"" where subtask_id = "%d" and status is not "cancelled";' % (
                                return_code, subtask_id)
                        execute, err = db.execute_iud(db_path, [
                            [status_update],
                        ],
                                                      get_rowid=True)
                        task_completed = False
                        break

                if task_completed:
                    status_update = "update tasks set status = 'completed' where task_id = '%d'" % task[
                        'task_id']
                else:
                    if attempts > 1:
                        status_update = "update tasks set status = 'error-retrying', attempts = %d where task_id = '%d' and status is not 'cancelled'" % (
                            attempts - 1, task['task_id'])
                    elif attempts == -2:
                        status_update = "update tasks set status = 'error-retrying', attempts = %d where task_id = '%d' and status is not 'cancelled'" % (
                            -2, task['task_id'])
                    else:
                        status_update = "update tasks set status = 'failed', attempts = '%d' where task_id = '%d' and status is not 'cancelled'" % (
                            0, task['task_id'])
                status, err = db.execute_iud(db_path, [
                    [status_update],
                ],
                                             get_rowid=True)
                if err:
                    raise Exception(err)

                if task_completed:
                    audit.audit("task_complete",
                                audit_str,
                                None,
                                system_initiated=True)
                else:
                    audit.audit("task_fail",
                                audit_str,
                                None,
                                system_initiated=True)

    except Exception as e:
        return False, 'Error processing tasks : %s' % e
    else:
        return True, None
Esempio n. 26
0
def create_share(name, comment, guest_ok, read_only, path, display_path,
                 browseable, users, groups, vol):
    try:
        db_path, err = common.get_db_path()
        if err:
            raise Exception(err)
        d, err = load_auth_settings()
        if err:
            raise Exception(err)
        if not d:
            raise Exception(
                "Authentication settings not set. Please set authentication settings before creating shares."
            )
        shl, err = load_shares_list()
        if err:
            raise Exception(err)
        if shl:
            for sh in shl:
                if sh["name"] == name:
                    raise Exception("A share with that name already exists")

        share_id, err = db.execute_iud(db_path, [[
            "insert into samba_shares (name, vol, path, display_path, comment, read_only, guest_ok, browseable, share_id) values (?,?, ?,?,?,?,?,?,NULL)",
            (
                name,
                vol,
                path,
                display_path,
                comment,
                read_only,
                guest_ok,
                browseable,
            )
        ]], True)
        if err:
            raise Exception(err)
        #print share_id, err
        cmd_list = []
        if not guest_ok:
            if users:
                for user in users:
                    cmd_list.append([
                        "insert into samba_valid_users (id, share_id, grp, name) values (NULL,?,?,?)",
                        (
                            share_id,
                            False,
                            user,
                        )
                    ])
            if groups:
                for group in groups:
                    cmd_list.append([
                        "insert into samba_valid_users (id, share_id, grp, name) values (NULL,?,?,?)",
                        (
                            share_id,
                            True,
                            group,
                        )
                    ])
        ret, err = db.execute_iud(db_path, cmd_list, True)
        if err:
            raise Exception(err)

    except Exception, e:
        return False, 'Error creating CIFS share : %s' % str(e)
def change_auth_method(security):

  cl = []
  cl.append(["update samba_global_common set security='%s' where id=1"%security])
  cl.append(["delete from samba_valid_users"])
  db.execute_iud("%s/integral_view_config.db"%db_path, cl)