Пример #1
0
def create_job():
    job_from_request = get_json_from_request('job')

    validation_result, validation_errors = valid_job_submission(job_from_request)
    if not validation_result:
        return jsonify(
            error="Invalid JSON",
            error_details=validation_errors
        ), 400

    job = Job(
        name=job_from_request['name'],
        service_id=job_from_request['serviceId'],
        created_at=datetime.utcnow()
    )

    if "filename" in job_from_request:
        job.filename = job_from_request['filename']

    try:
        db.session.add(job)
        db.session.commit()
        return jsonify(
            job=job.serialize()
        ), 201
    except IntegrityError as e:
        db.session.rollback()
        abort(400, e.orig)
Пример #2
0
def create_job(
        template,
        notification_count=1,
        created_at=None,
        job_status='pending',
        scheduled_for=None,
        processing_started=None,
        original_file_name='some.csv',
        archived=False
):
    data = {
        'id': uuid.uuid4(),
        'service_id': template.service_id,
        'service': template.service,
        'template_id': template.id,
        'template_version': template.version,
        'original_file_name': original_file_name,
        'notification_count': notification_count,
        'created_at': created_at or datetime.utcnow(),
        'created_by': template.created_by,
        'job_status': job_status,
        'scheduled_for': scheduled_for,
        'processing_started': processing_started,
        'archived': archived
    }
    job = Job(**data)
    dao_create_job(job)
    return job
Пример #3
0
def new_job():

    form = JobForm()
    form.customer_name.choices = [("", "Select Name")] + [
        (c.id, c.name) for c in Customer.query.order_by('name')
    ]
    form.project_number.choices = [("", "Select Number")] + [
        (p.id, p.number) for p in Project.query.order_by('number')
    ]
    form.project_name.choices = [("", "Select Name")] + [
        (p.id, p.name) for p in Project.query.order_by('name')
    ]

    if form.validate_on_submit():
        job = Job(project_id=form.project_name.data,
                  phase=form.phase.data,
                  job_type=form.job_type.data)
        db.session.add(job)
        db.session.commit()
        flash(
            f'Job {job.project_name()} {job.phase} {job.job_type} has been added to the database.'
        )
        return redirect(url_for('main.index'))

    return render_template('new_job.html', title='New Job', form=form)
Пример #4
0
def sample_email_job(notify_db,
                     notify_db_session,
                     service=None,
                     template=None):
    if service is None:
        service = sample_service(notify_db, notify_db_session)
    if template is None:
        template = sample_email_template(
            notify_db,
            notify_db_session,
            service=service)
    job_id = uuid.uuid4()
    data = {
        'id': job_id,
        'service_id': service.id,
        'service': service,
        'template_id': template.id,
        'template_version': template.version,
        'original_file_name': 'some.csv',
        'notification_count': 1,
        'created_by': service.created_by
    }
    job = Job(**data)
    dao_create_job(job)
    return job
Пример #5
0
def sample_job(notify_db,
               notify_db_session,
               service=None,
               template=None,
               notification_count=1,
               created_at=None,
               job_status='pending',
               scheduled_for=None,
               processing_started=None,
               original_file_name='some.csv',
               archived=False):
    if service is None:
        service = create_service(check_if_service_exists=True)
    if template is None:
        template = create_template(service=service)
    data = {
        'id': uuid.uuid4(),
        'service_id': service.id,
        'service': service,
        'template_id': template.id,
        'template_version': template.version,
        'original_file_name': original_file_name,
        'notification_count': notification_count,
        'created_at': created_at or datetime.utcnow(),
        'created_by': service.created_by,
        'job_status': job_status,
        'scheduled_for': scheduled_for,
        'processing_started': processing_started,
        'archived': archived
    }
    job = Job(**data)
    dao_create_job(job)
    return job
def save_city_given_list_of_posts(posts, month, year):
    all_cities = {
        city: id
        for (city, id) in db.session.query(City.name, City.id).all()
    }
    unmatched_jobs = []
    # posts is a list of tuples (html_post, plain_post, hackernews_hd)
    for post in posts:
        at_least_one_match = False
        (html_post, plain_post, hn_id) = post
        for city in all_cities:
            maybe_city = plain_post.find(city)
            if maybe_city != -1:
                if re.match(city + '([^a-z]|$)', plain_post[maybe_city:]):
                    newJob = Job(unicode(html_post), month, year, hn_id,
                                 all_cities[city])
                    db.session.add(newJob)
                    at_least_one_match = True
        if not at_least_one_match:
            unmatched_jobs.append((plain_post, hn_id))
    db.session.commit()
    db.session.close()

    if not os.path.exists('debug'):
        os.makedirs('debug')
    with open('debug/no_matches-{0}-{1}.txt'.format(month, year), 'w') as f:
        for (job, hn_id) in unmatched_jobs:
            f.write(hn_id)
            f.write(job.encode('utf-8'))
Пример #7
0
def started_job(job_id):
    command = request.json['command']
    job = Job.objects(id=job_id).first()
    job.status = 'started'
    job.command = command
    job.save()
    return jsonify({'message': 'ok'})
Пример #8
0
def sample_job(
    notify_db,
    notify_db_session,
    service=None,
    template=None,
    notification_count=1,
    created_at=None,
    job_status="pending",
    scheduled_for=None,
    processing_started=None,
    original_file_name="some.csv",
    archived=False,
):
    if service is None:
        service = create_service(check_if_service_exists=True)
    if template is None:
        template = create_template(service=service)
    data = {
        "id": uuid.uuid4(),
        "service_id": service.id,
        "service": service,
        "template_id": template.id,
        "template_version": template.version,
        "original_file_name": original_file_name,
        "notification_count": notification_count,
        "created_at": created_at or datetime.utcnow(),
        "created_by": service.created_by,
        "job_status": job_status,
        "scheduled_for": scheduled_for,
        "processing_started": processing_started,
        "archived": archived,
    }
    job = Job(**data)
    dao_create_job(job)
    return job
Пример #9
0
def list_jobs():
    if request.method == 'POST':



        # print(request.data)
        # print(type(request.data))
        data_dict = json.loads(request.data)
        # print(data_dict)
        # print(type(data_dict))
        job_object = Job(events=data_dict.get('events'), name=data_dict.get('name'),
                         out_dir=data_dict.get('out_dir'), log_dir=data_dict.get('log_dir'),
                         new_file=data_dict.get('new_file'))

        job_object.save()

        if data_dict.get('start') is True:
            job_object.start()
            started = True
        else:
            started = False

        return jsonify({'job_id': str(job_object.job_id),
                        'started': started})

    else:
        # Needs testing, potentially bad practice.
        # print([job.get() for job in Job.objects()])
        return jsonify({"jobs": [job.get() for job in Job.objects()]})
Пример #10
0
def batch_import_route():
    # only for users who have custom domains
    if not current_user.verified_custom_domains():
        flash("Alias batch import is only available for custom domains",
              "warning")

    if current_user.disable_import:
        flash(
            "you cannot use the import feature, please contact SimpleLogin team",
            "error",
        )
        return redirect(url_for("dashboard.index"))

    batch_imports = BatchImport.filter_by(user_id=current_user.id).all()

    if request.method == "POST":
        alias_file = request.files["alias-file"]

        file_path = random_string(20) + ".csv"
        file = File.create(user_id=current_user.id, path=file_path)
        s3.upload_from_bytesio(file_path, alias_file)
        Session.flush()
        LOG.d("upload file %s to s3 at %s", file, file_path)

        bi = BatchImport.create(user_id=current_user.id, file_id=file.id)
        Session.flush()
        LOG.d("Add a batch import job %s for %s", bi, current_user)

        # Schedule batch import job
        Job.create(
            name=JOB_BATCH_IMPORT,
            payload={"batch_import_id": bi.id},
            run_at=arrow.now(),
        )
        Session.commit()

        flash(
            "The file has been uploaded successfully and the import will start shortly",
            "success",
        )

        return redirect(url_for("dashboard.batch_import_route"))

    return render_template("dashboard/batch_import.html",
                           batch_imports=batch_imports)
Пример #11
0
 def insert_one(self, job):
     """Insert a New Job"""
     job = Job(
         name=job["name"],
         status=self.PENDING if job["interval"]["type"] == self.ONCE or job["interval"]["type"] == self.AFTER or job["interval"]["type"] == self.ONCE_AT else self.DAEMON,
         last_status=self.PENDING if job["interval"]["type"] == self.ONCE or job["interval"]["type"] == self.AFTER or job["interval"]["type"] == self.ONCE_AT else self.DAEMON,
         executor=job["executor"],
         parameters=json.dumps(job["parameters"]),
         interval=json.dumps(job["interval"]),
         retry_count=job["retry_count"] if "retry_count" in job else 0,
         trials=job["trials"] if "trials" in job else 5,
         priority=job["priority"] if "priority" in job else 1,
         last_run=job["last_run"] if "last_run" in job else None,
         run_at=job["run_at"] if "run_at" in job else self.get_run_at(job["interval"]),
         locked=job["locked"] if "locked" in job else False,
     )
     job.save()
     return False if job.pk is None else job
Пример #12
0
def finished_job(job_id):
    job = Job.objects(id=job_id).first()
    job.status = 'finished'
    job.save()

    user = User.objects(id=job.user_id).first()
    mailer.notify(job, user, job_id)

    return jsonify({'message': 'ok'})
Пример #13
0
def search():
    if not g.search_form.validate():
        return redirect(url_for('jobs'))
    jobs_results, total = Job.search(g.search_form.q.data)

    return render_template('search.html',
                           title=('Search'),
                           jobs_results=jobs_results,
                           total=total)
Пример #14
0
def create_and_start_job(sim_id, form, extra_file=None):
    job_attrs = dict()
    data = {
        'simulator': sim_id,
        'status': 'created',
        'user_id': current_user.id,
        'attrs': job_attrs
    }
    for name, value in form.data.items():
        if name == 'name':
            data['name'] = value
        elif name == 'privacy':
            data['privacy'] = value
        elif name == 'sequence_identifier':
            # NOTE: sequence identifier is for artificialfastqgenerator where
            # this field must be the header to a sequence and it must start with >
            job_attrs[name] = str(value)[1:]
        elif isinstance(value, bool):
            # NOTE: let 1 equal true and 0 false
            job_attrs[name] = '1' if value else '0'
        elif name != 'csrf_token' and name != 'file' and name != 'submit':
            job_attrs[name] = str(value)

    if extra_file is not None:
        job_attrs['extra_file'] = 'extra_file'

    # Apply the job's tags to the dictionary to be stored in the database.
    for key in ['ref_db', 'genomics', 'tech', 'variants']:
        data[key] = SIMULATORS[sim_id][key]

    job = Job(**data)
    job.save()

    # If there is no job name, then set the job id as the job name.
    if job.name == '':
        job.name = str(job.id)
        job.save()

    client = arc.Client('newriver1.arc.vt.edu', arc.ARC_USER)
    remote_path = arc.get_remote_path(job.id)
    client.run('mkdir {}'.format(remote_path))

    # The path where all output files are written to is the project's directory.
    # NOTE: not all simulators have an input file (ex. xs)
    if hasattr(form, 'file'):
        project_dir = os.path.join(arc.ARC_DIR, str(job.id))
        filename = form.file.data.filename
        tmp_path = os.path.join('/tmp', filename)
        form.file.data.save(tmp_path)

        client.put_file(tmp_path, os.path.join(remote_path, 'input.fasta'))

    if extra_file is not None:
        tmp_path = os.path.join('/tmp', 'extra_file')
        extra_file.data.save(tmp_path)
        client.put_file(tmp_path, os.path.join(remote_path, 'extra_file'))

    client.close()
    start_job.apply_async(args=[str(job.id)])
Пример #15
0
def notify_db_session(request):

    meta = MetaData(bind=db.engine, reflect=True)

    # Set up dummy org, with a service and a job
    org = Organisation(id=1234, name="org test")
    token = Token(id=1234, token="1234", type='admin')
    service = Service(
        id=1234,
        name="service test",
        created_at=datetime.utcnow(),
        token=token,
        active=True,
        restricted=False,
        limit=100
    )
    job = Job(id=1234, name="job test", created_at=datetime.utcnow(), service=service)
    notification = Notification(
        id=1234,
        to="phone-number",
        message="this is a message",
        job=job,
        status="created",
        method="sms",
        created_at=datetime.utcnow()
    )

    # Setup a dummy user for tests
    user = User(
        id=1234,
        email_address="*****@*****.**",
        mobile_number="+449999234234",
        password=generate_password_hash('valid-password'),
        active=True,
        created_at=datetime.utcnow(),
        updated_at=datetime.utcnow(),
        password_changed_at=datetime.utcnow(),
        role='admin'
    )

    service.users.append(user)

    db.session.add(token)
    db.session.add(org)
    db.session.add(service)
    db.session.add(notification)
    db.session.add(job)
    db.session.add(user)
    db.session.commit()

    def teardown():
        db.session.remove()
        for tbl in reversed(meta.sorted_tables):
            db.engine.execute(tbl.delete())

    request.addfinalizer(teardown)
Пример #16
0
def company(company_name):
    company = Startup.query.filter_by(company_name=company_name).first_or_404()
    # for now, but I have to see how competitors treat this
    form = PostNewJobForm()
    is_admin = (current_user.startup.first() == company)
    if is_admin:
        jobs = company.jobs
        no_jobs = (len([job for job in jobs]) == 0)
    else:
        jobs, no_jobs = None, True
    logo_pic = company.logo_data is not None
    logo_url = None
    if logo_pic:
        url = company.logo_data.split('/')
        logo_url = "/{0}/{1}".format(url[-2], url[-1])
    if form.validate_on_submit():
        kwargs = {
            'name': form.name.data,
            'job_description': form.job_description.data,
            'offer_price': form.offer_price.data,
            'job_type': form.job_type.data,
            'estimated_developement_time':
            form.estimated_developement_time.data,
            'equity_job': form.equity_job.data
        }
        job = Job(**kwargs)
        job.post_job_time()
        db.session.add(job)
        company.create_job(job)
        db.session.commit()
        flash('Successfully created new job')
        return redirect(url_for('company', company_name=company_name))
    kwargs = {
        'title': company_name,
        'company_name': company_name,
        'company': company,
        'is_admin': is_admin,
        'jobs': jobs,
        'no_jobs': no_jobs,
        'logo_url': logo_url,
        'form': form
    }
    return render_template('company.html', **kwargs)
Пример #17
0
def make_dummy_job():
    job = Job(complete=False,
              error=False,
              visited=datetime.now(),
              buildid='buildid',
              timing=0.0,
              script="""
        with import <nixpkgs> {};
        stdenv.mkDerivation {
        name = "example";
            phases = "installPhase";
            installPhase = ''
            echo "Random String: """ + uuid.uuid4().hex + """\";
            mkdir $out
            touch $out/hello
            '';
        }
        """)
    job.save()
Пример #18
0
def importComments(_fileList):

    # load all cities in a dict for faster lookup
    dd = {
        city: id
        for (city, id) in db.session.query(City.name, City.id).all()
    }

    s = bs(open(os.path.join('hn-pages', _fileList)))
    t = s.title.get_text()
    title = t[t.index('(') + 1:t.index(')')].split(' ')
    month = monthify(title[0])
    year = title[1]

    # let's dig through this thing
    hnmain = s.find('table')
    outerTable = hnmain.findAll('tr')[3]
    innerTable = outerTable.findAll('table')[1]

    # inside innerTable, every <tr> is a post,
    # but the actual stuff in nested in yet another <tr> (wtf?)
    posts = innerTable.findAll('tr', recursive=False)

    with open('hn-pages/debug-{0}-{1}.txt'.format(year, month), 'w') as f:
        for p in posts:
            c = p.find('tr')
            # if the post is not a reply, process it
            if c.find(
                    lambda tag: tag.name == 'img' and int(tag['width']) == 0):
                content = c.find('span', class_='comment')
                plain = content.get_text()
                found_flag = False
                for city in dd:
                    position = plain.find(city)
                    if position != -1:
                        found_flag = True
                        if re.match(city + '([^a-z]|$)', plain[position:]):
                            # get the original HN id and push the new job
                            hn_id = c.findAll('a')[2]['href'].split('=')[1]
                            newJob = Job(unicode(content), month, year, hn_id,
                                         dd[city])
                            db.session.add(newJob)
                        else:
                            f.write('--DITCHED BY REGEX--\n')
                            f.write(plain[position:position +
                                          50].encode('utf-8'))
                            f.write('\n\n\n')
                if not found_flag:
                    f.write('--NO CITY FOUND FOR--\n')
                    f.write(plain.encode('utf-8'))
                    f.write('\n\n\n')
        # end of for p in posts
        f.write('Imported successfully!')
        db.session.commit()
        db.session.close()
Пример #19
0
def past_jobs_pretty():
    past_jobs = []

    for job in Job.get_past_jobs():
        past_jobs.append(
            (str(job.id),
             '{} on {}, {}'.format(job.address,
                                   timestamp_pretty(job.date, show_time=False),
                                   job.time)))

    return past_jobs
Пример #20
0
def save():
    try:
        # get headers first
        # save through headers
        # jobtitle = request.headers.get('jobtitle')
        # company = request.headers.get('company')
        # city = request.headers.get('city')
        # state = request.headers.get('state')
        # zip = request.headers.get('zip')
        # descr = request.headers.get('descr')
        # jstatus = request.headers.get('jstatus')
        # link = request.headers.get('link')
        # duties = request.headers.get('duties')
        # requi = request.headers.get('requi')
        # post_date = request.headers.get('post_date')

        # save through parameters
        jobtitle = request.args.get('jobtitle')
        company = request.args.get('company')
        city = request.args.get('city')
        state = request.args.get('state')
        zip = request.args.get('zip')
        descr = request.args.get('descr')
        jstatus = request.args.get('jstatus')
        link = request.args.get('link')
        duties = request.args.get('duties')
        requi = request.args.get('requi')
        post_date = request.args.get('post_date')

        if not jobtitle and not company and not city and not state and not zip and not descr and not jstatus and not link and not duties and not requi and not post_date:
            return jsonify({'error #301': 'Invalid params'})

        # create an event
        job = Job(jobtitle=jobtitle,
                  company=company,
                  city=city,
                  state=state,
                  zip=zip,
                  descr=descr,
                  jstatus=jstatus,
                  link=link,
                  duties=duties,
                  requi=requi,
                  post_date=post_date)

        # add to stage and commit to db
        db.session.add(job)
        db.session.commit()

        return jsonify({'success': 'job saved'})
    except:
        return jsonify({'error #303': 'job could not be saved'})
Пример #21
0
def initiate_video():
    if request.method == 'POST':
        data = request.form
        if 'video_name' not in data or 'video_url' not in data:
            raise InvalidUsage('Data must contain video_name and video_url')
        video = Video(name=data['video_name'], url=data['video_url'])
        db.session.add(video)
        db.session.commit()
        task = split_video.delay(video.id)
        job = Job(desc=SPLIT_JOB_DESC, celery_id=task.id, video=video)
        db.session.add(job)
        db.session.commit()
        return redirect(url_for('jobs', video_id=video.id))
    return render_template('submit_job.html')
Пример #22
0
def create_job():
    job_from_request = get_json_from_request('job')

    validation_result, validation_errors = valid_job_submission(
        job_from_request)
    if not validation_result:
        return jsonify(error="Invalid JSON",
                       error_details=validation_errors), 400

    job = Job(name=job_from_request['name'],
              service_id=job_from_request['serviceId'],
              created_at=datetime.utcnow())

    if "filename" in job_from_request:
        job.filename = job_from_request['filename']

    try:
        db.session.add(job)
        db.session.commit()
        return jsonify(job=job.serialize()), 201
    except IntegrityError as e:
        db.session.rollback()
        abort(400, e.orig)
Пример #23
0
def addjob():
    if request.method == 'POST':
        data = {}
        req = request.form
        if current_user.is_authenticated:
            user = User.query.get(current_user.get_id())
            if not user.user_roll() == "Employer":
                return "You Don't Permission To Access This Page"
            data['title'] = req['title']
            data['description'] = req['description']
            #data['email']=req['email']
            data['type'] = req['type']
            data['category'] = req['category']
            data['experience'] = req['experience']
            data['salary'] = req['salary']
            data['clevel'] = req['clevel']
            data['industry'] = req['industry']
            data['qualification'] = req['qualification']
            data['deadline'] = req['deadline']
            data['country'] = req['country']
            data['city'] = req['city']
            data['address'] = req['address']
            data['openings'] = req['openings']

            ft = False
            if data['type'] == 'true':
                ft = True
            else:
                ft = False
            today = datetime.strptime(data['deadline'], '%Y-%m-%d').date()
            eid = Employer.query.filter_by(
                user_id=current_user.get_id()).first_or_404()
            newjob = Job(title=data['title'],
                         jobdesc=data['description'],
                         exp=data['experience'],
                         qualification=data['qualification'],
                         career_level=data['clevel'],
                         location=data['address'],
                         fulltime=ft,
                         city=data['city'],
                         salary=data['salary'],
                         user_id=eid.id,
                         category=data['category'],
                         openings=data['openings'],
                         expiry_date=today)
            db.session.add(newjob)
            db.session.commit()
            print("-----new job added-----")
            return redirect(url_for('manageJob'))
Пример #24
0
def add_job(request):
    try:
        request_data = json.loads(json.dumps(request.data))
        tags = request_data.get('tags').split(",")
        Job(company_image=request_data.get('companyImage'),
            company_name=request_data.get('companyName'),
            job_title=request_data.get('jobTitle'),
            job_location=request_data.get('jobLocation'),
            job_link=request_data.get('jobLink'),
            job_content=request_data.get('jobContent'),
            tags=tags,
            automated=False).save()
        return Response({"saved": 1})
    except:
        return Response({"saved": 0})
Пример #25
0
def sample_letter_job(sample_letter_template):
    service = sample_letter_template.service
    data = {
        "id": uuid.uuid4(),
        "service_id": service.id,
        "service": service,
        "template_id": sample_letter_template.id,
        "template_version": sample_letter_template.version,
        "original_file_name": "some.csv",
        "notification_count": 1,
        "created_at": datetime.utcnow(),
        "created_by": service.created_by,
    }
    job = Job(**data)
    dao_create_job(job)
    return job
Пример #26
0
def sample_letter_job(sample_letter_template):
    service = sample_letter_template.service
    data = {
        'id': uuid.uuid4(),
        'service_id': service.id,
        'service': service,
        'template_id': sample_letter_template.id,
        'template_version': sample_letter_template.version,
        'original_file_name': 'some.csv',
        'notification_count': 1,
        'created_at': datetime.utcnow(),
        'created_by': service.created_by,
    }
    job = Job(**data)
    dao_create_job(job)
    return job
Пример #27
0
def create_job_post():
    form = JobForm()
    if form.validate_on_submit():
        postImage = ""
        if form.postImage.data:
            postImage = save_post_image(form.postImage.data)
        post = Job(Title=form.title.data,
                   Content=form.content.data,
                   ImageFile=postImage)
        db.session.add(post)
        db.session.commit()
        flash("Succesfully Posted!", category='success')
        return redirect(url_for('main.job'))

    return render_template('job/create-job-post.html',
                           form=form,
                           title="Make a story")
Пример #28
0
def newJob():
    form = JobForm()
    if request.method == "POST" and form.validate_on_submit():
        #create a job object and add it to the database
        job = Job(
            request.form['jTitle'],
            request.form['jDesc'],
            request.form['category'],
            request.form['company'],
            request.form['jLoc'],
            datetime.now()
        )

        db.session.add(job)
        db.session.commit()
        flash('Job Added', 'success')
        return redirect(url_for("home"))
    return render_template('', form=form)
Пример #29
0
    def test_basic_functionality(self):

        jobStatusId = JobStatus.query.filter_by(
            label='running').first().statusId

        self.assertIsNotNone(jobStatusId)

        testLabel = 'test job 1'

        db.session.add(Job(label=testLabel, statusId=jobStatusId))

        db.session.commit()

        testJob = Job.query.filter_by(label=testLabel).first()

        self.assertIsNotNone(testJob)
        self.assertEqual(testJob.status.label, 'running')
        self.assertEqual(testJob.type, 'job')
Пример #30
0
 def test_subcat_cat(self):
     cat = Cat(name='Web Developement')
     sub = Sub(name='Frontend')
     job = Job(name='A')
     db.session.add_all([cat, sub, job])
     db.session.commit()
     job.add_cat(cat)
     cat.assign_sub_cat(sub)
     db.session.commit()
     job.add_sub_cat(sub)
     db.session.commit()
     check = (sub in job.subs)
     self.assertTrue(check)
Пример #31
0
def sample_email_job(notify_db, notify_db_session, service=None, template=None):
    if service is None:
        service = create_service(check_if_service_exists=True)
    if template is None:
        template = sample_email_template(notify_db, notify_db_session, service=service)
    job_id = uuid.uuid4()
    data = {
        "id": job_id,
        "service_id": service.id,
        "service": service,
        "template_id": template.id,
        "template_version": template.version,
        "original_file_name": "some.csv",
        "notification_count": 1,
        "created_by": service.created_by,
    }
    job = Job(**data)
    dao_create_job(job)
    return job
Пример #32
0
 def create(matrixA, matrixB):
     job = Job(matrixA, matrixB)
     db.session.add(job)
     db.session.commit()
     job.loadMatrices(matrixA, matrixB)
     return job
Пример #33
0
    def submit(self, run, analysis, cfg):
        ana_name, ana_template, ana_context, ana_post_exec = (
            cfg['name'],
            cfg['template'],
            cfg.get('context',{}),
            cfg.get('post_exec',None)
        )
        logger.info('Create job for run %d, analysys %s' %
                    (run.RunNumber, ana_name))

        job = Job(Run=run, Analysis=analysis)
        job.save()

        # Create directory
        job_dir = os.path.join(
            settings.CAF_OUTPUT,
            "%08d_%s_%d" % (run.RunNumber, ana_name, job.id)
        )
        try:
            os.makedirs(job_dir)
        except:
            logger.exception("Could not create directory %s", job_dir)
            job.delete()
            return 

        # Copy files for job
        tmpl = get_template('joboptions/%s.py.tmpl' % ana_template)
        ana_context.update({'files': run.Files.all()})
        jobo = tmpl.render(ana_context)

        jopo_path = os.path.join(job_dir, 'jobo.py')
        with open(jopo_path, 'w') as f:
            f.write(jobo)
  
        post_exec = ''
        if ana_post_exec:
            post_exec = get_template('%s.sh.tmpl' % ana_post_exec).render(
                {
                    'BASE_DIR': settings.BASE_DIR
                }
            )

        launcher = get_template('launcher.sh.tmpl').render(
            {
                'athena_version': settings.CAF_ATHENA,
                'asetup': settings.CAF_ASETUP,
                'post_exec': post_exec,
                'BASE_DIR': settings.BASE_DIR
            }
        )
        
        launcher_path = os.path.join(job_dir, 'launcher.sh')
        with open(launcher_path, 'w') as f:
            f.write(launcher)
        st = os.stat(launcher_path)
        os.chmod(launcher_path, st.st_mode | stat.S_IEXEC)

        output_path = os.path.join(job_dir, 'stdout.log')
        err_path = os.path.join(job_dir, 'stderr.log')
        
        with nested(open(output_path, 'w'), open(err_path, 'w')) as (out, err):
            process = subprocess.Popen(launcher_path, cwd=job_dir, stdout=out, stderr=err)
            pid_path = os.path.join(job_dir, 'pid')
            with open(pid_path, 'w') as pid:
                pid.write(str(process.pid))
            job.IsLocal = True
            job.ExternalId = process.pid
            job.Status = Job.RUNNING
            job.save()
Пример #34
0
def create_sms_notification():
    if not current_app.config['SMS_ENABLED']:
        return jsonify(error="SMS is unavailable"), 503

    notification_request = get_json_from_request('notification')

    validation_result, validation_errors = valid_sms_notification(notification_request)

    if not validation_result:
        return jsonify(
            error="Invalid JSON",
            error_details=validation_errors
        ), 400

    incoming_token = get_token_from_headers(request.headers)

    if not incoming_token:
        return jsonify(error="No credentials supplied"), 400

    service = Service.query.join(Token).filter(Token.token == incoming_token).first()

    if not service:
        return jsonify(error="No service associated with these credentials"), 400

    if not service.active:
        return jsonify(error="Service is inactive"), 400

    if "jobId" in notification_request:
        job = Job.query.filter(Job.id == notification_request["jobId"]).first()
        if not job:
            return jsonify(error="No job associated with this job id"), 400
        elif job.service_id != service.id:
            abort(400, "Invalid job id for these credentials")
    else:
        job = Job(name="Autogenerated", created_at=datetime.utcnow(), service=service)

    if service.restricted:
        if not notification_request['to'] in [user.mobile_number for user in service.users]:
            abort(400, "Restricted service: cannot send notification to this number")

    usage = Usage.query.filter(Usage.day == datetime.utcnow().date(), Usage.service_id == service.id).first()
    if usage:
        usage.count += 1
    else:
        usage = Usage(
            day=datetime.utcnow().date(),
            count=1,
            service_id=service.id
        )

    if usage.count > service.limit:
        abort(429, "Exceeded sending limits for today")

    notification = Notification(
        to=notification_request['to'],
        message=notification_request['message'],
        status='created',
        method='sms',
        created_at=datetime.utcnow(),
        job=job
    )

    if 'description' in notification_request:
        job.name = notification_request['description']

    try:
        db.session.add(usage)
        db.session.add(notification)
        db.session.commit()

        send_messages_to_queue('sms', [notification])

    except IntegrityError:
        db.session.rollback()
        abort(400, "Failed to create notification: DB error")

    return jsonify(notification=Notification.query.filter(Notification.id == notification.id).first().serialize()), 201