Exemplo n.º 1
0
def schedule_queries(_id, trip_array):
	#_id: This is the original trip _id

	#start, end must both be represented as strings which contain the latitude and longitude of the location
	#purturbed_time must be a datetime object.
	#start/end: 'lat1,lon1'
	#example location input: '-33.8674869,151.2069902'
	#example use case:
	#schedule_query(start='-33.8674869,151.2069902', end='-33.8674869,151.2069902', time=datetime.datetime.now() + datetime.timedelta(days=10))

	#TODO: write regex to enforce that passed in locations are geocoded; i.e. lat1,lon1, lat2,lon2
	#TODO: this will run every year, need to figure out if python crontab can support yearly configuration so it only runs once

	for trip in trip_array:
		start = trip.get_start_coordinates()
		end = trip.get_end_coordinates()
		time = trip.get_time()

		cron = CronTab()
		exec_str = python_location + ' ' + query_script_location + ' ' + _id
		job = cron.new(command=exec_str)

		job.month.on(perturbed_time.month)
		job.day.on(perturbed_time.day)
		job.hour.on(perturbed_time.hour)
		job.minute.on(perturbed_time.minute)

		job.enable()
		cron.write()
		print("You have successfully scheduled this CRON job.")
Exemplo n.º 2
0
 def schedule(self):
     cron = CronTab()
     for schedule in self.collection.find():
         job  = cron.new(command='python /backyarbarber/python/controller.py startMower')
         min = schedule["time"]["minute"]
         hour = schedule["time"]["hour"]
         days = schedule["days"]
         dayString = ""
         if days["Sunday"]:
             dayString += ",0"
         elif days["Monday"]:
             dayString += ",1"
         elif days["Tuesday"]:
             dayString += ",2"
         elif days["Wednesday"]:
             dayString += ",3"
         elif days["Thursday"]:
             dayString += ",4"
         elif days["Friday"]:
             dayString += ",5"
         elif days["Saturay"]:
             dayString += ",6"
         if dayString[0] == ',':
             dayString = dayString[1:]
         job.minute.on(min)
         job.hour.on(hour)
         job.days.on(dayString)
         job.enable()
Exemplo n.º 3
0
def build_cron_job(jobs, dest_d=None):
	from crontab import CronTab

	tabfile = os.path.join(BASE_DIR if dest_d is None else dest_d, "cron.tab")
	cron = CronTab()

	try:
		for j in jobs:
			if j['unit'] not in cron_units:
				continue

			if 'frequency' not in j.keys():
				continue

			job = cron.new(
				command=j['command'],
				comment=j['comment'])

			if j['unit'] in ["mins", "minutes", "min", "minute"]:
				job.every(j['frequency']).minutes()
			elif j['unit'] in ["hours", "hour"]:
				job.every(j['frequency']).hours()
			elif j['unit'] in ["days", "day"]:
				job.every(j['frequency']).days()

		cron.write(tabfile)
		return True

	except Exception as e:
		print e, type(e)

	return False
Exemplo n.º 4
0
    def run(self):
        """default method"""

        sess = Session()
        sender = self.req_obj.get('sender', '')
        #exctract sender email
        email = sender.split('/')[0]
        #find user profile by primary email
        profile = sess.query(Profile).filter(Profile.email == email).one()

        cron = CronTab(getuser())
        msg = ''
        job = cron.new(command='/usr/bin/python %s/core/cron/cronjob.py --uuid=%s --cmd="check my sites" --arguments="%s"' % (ROBOT_DIR, profile.uuid, msg.replace('"', '')))

        #every hour
        job.minute.on(0)
        cron.write()
        response = 'ok, cronjob added %s' % job.render()

        if self.req_from == 'jabber':
            todo = {'text': response, 'jmsg': response, 'type': 'response'}
            self.response = todo

        if self.req_from == 'julius':
            bang()
            todo = {'say': response, 'text': response, 'type': 'response'}
            self.response = say(self.request.replace('say', '').upper())

        return self.response
Exemplo n.º 5
0
	def delete_job(self, cron_id=None):
		cron = CronTab(user=True)
		jobs = self.get_cron_job(cron_id, cron=cron)
		for job in jobs:
			cron.remove(job)
		cron.write()
		return jobs
Exemplo n.º 6
0
	def new_job(self, folder=None, minute=None, hour=None, month=None, day_of_month=None, day_of_week=None):
		cron = CronTab(user=True)
		fileName = "%s.jpg" % (strftime("%Y-%m-%d %I.%M.%S %pe"))
		if folder is None:
			folder = "images"

		cmd = "raspistill -vf -hf -o %s/%s/$(date '+%%m-%%d-%%y_%%H:%%M:%%S').jpg" % (getcwd(), folder)
		
		if minute is None and hour is None and month is None and day_of_month is None and day_of_week is None:
			call(cmd)
			return None
		else:
			while True:
				cron_id = '%04d' % randint(0,9999)
				conflicting_cron_jobs = self.get_cron_job(cron_id)
				if len(conflicting_cron_jobs) == 0: break

			job = cron.new(command=cmd,comment="%s%s" % (self.comment_prefix, cron_id))

			if minute is None: minute = "*"
			if hour is None: hour = "*"
			if month is None: month = "*"
			if day_of_month is None: day_of_month = "*"
			if day_of_week is None: day_of_week = "*"
			job.setall(minute, hour, day_of_month, month, day_of_week)
			
			cron.write()
			return job
Exemplo n.º 7
0
def servicesStart():
  cron = CronTab(user=True)
  for job in cron.find_comment('polis'):
    if job.comment == 'polis':
      print("**WARNING: Polis services already running -- run 'polis stop'", file=sys.stderr)
      sys.exit(2)
  for i in range(len(SOURCES)):
    root_dir = ROOT_DIR
    logfile = SOURCES[i]["LOGFILE"]
    daemon = SOURCES[i]["DAEMON"]
    freq = SOURCES[i]["FREQ"]
    command_string = "python " + root_dir + "/python/" + daemon + " > " + logfile + " 2>&1"
    job = cron.new(command=command_string, comment='polis')
    try:
      # first entry set to 0 -- otherwise a new script spawns every minute
      job.setall("0 %s * * *" % freq)
    except:
      print("**ERROR: Could not set %s" % daemon, file=sys.stderr)
      print("Check config.py for invalid frequency settings", file=sys.stderr)
      sys.exit(3)
  for job in cron:
    if job.is_valid():
      print(job.command)
    else:
      print("**ERROR: Invalid job: %s" % job.command)
      sys.exit(4)
  # assuming all goes well:
  cron.write()
Exemplo n.º 8
0
def install_buildbot_slave(name, path=None, script_dir='', shell=False, **args):
  username = '******'
  if platform.system() == 'Linux':
    # Create buildbot user if it doesn't exist.
    username = '******'
    import pwd
    try:
      pwd.getpwnam(username)
    except KeyError:
      check_call(['sudo', 'useradd', '--system', '--home', '/var/lib/buildbot',
                  '--create-home', '--shell', '/bin/false', 'buildbot'])
  path = path or os.path.expanduser('~{0}/slave'.format(username))
  if os.path.exists(path):
    return
  pip_install('buildbot-slave', 'buildbot')
  # The password is insecure but it doesn't matter as the buildslaves are
  # not publicly accessible.
  command = [os.path.join(script_dir, 'buildslave'),
             'create-slave', path, args.get('ip', '10.0.2.2'), name, 'pass']
  if not windows:
    command = ['sudo', '-u', username] + command
  check_call(command, shell=shell)
  if windows:
    return
  if args.get('nocron', False):
    return
  pip_install('python-crontab', 'crontab')
  from crontab import CronTab
  cron = CronTab(username)
  cron.new('PATH={0}:/usr/local/bin buildslave start {1}'.format(
    os.environ['PATH'], path)).every_reboot()
  cron.write()
  # Ignore errors from buildslave as the buildbot may not be accessible.
  call(['sudo', '-H', '-u', username, 'buildslave', 'start', path])
Exemplo n.º 9
0
 def add_system_cron(self, **kwargs):
     cronfile = kwargs.get("filename", "/etc/crontab")
     cron = CronTab(tabfile=cronfile, user=False)
     job = self.add_cron_command(cron, **kwargs)
     job.user = "******"
     cron.write()
     return True
Exemplo n.º 10
0
def time_change(message):
    hour, minute = message["data"].split(":")
    print("New wake up time: {}-{}".format(hour, minute))
    TEST = True
    if TEST:
        cron = CronTab(tabfile="test.CronTab")
    else:
        cron = CronTab(user=True)

    # get already created crontab
    for job in cron.find_comment("clock weekday"):
        print(job)
        if job.hour == hour and job.minute == minute:
            pass
        else :
            #remove old cron
            cron.remove_all(comment="clock weekday")
            job = cron.new(command="python /home/pi/sunlight_alarm_clock/light/python/transition.py", comment='clock weekday')
            job.hour.on(hour)
            job.minute.on(minute)
            schedule = job.schedule(date_from=datetime.now())
            if TEST:
                cron.write("test.CronTab")
            else:
                cron.write()
Exemplo n.º 11
0
    def test_insert(self):
        '''Insert a job, It should insert a job and return it with id'''
        result = self.schedule.insert({
            "enable": 1,
            "alias": "reboot",
            "command": "uptime && test_insert",
            "schedule": "0 0 * * *",
            "executer": True
        })

        self.assertDictEqual({
            "id": 2,
            "enable": 1,
            "alias": "reboot",
            "command": "uptime && test_insert",
            "schedule": "0 0 * * *",
            "executer": True,
            "comment": "sanji_schedule_2"
        }, result)

        jobs = []
        cron = CronTab(user=True)
        for job in cron.find_comment("sanji_schedule_2"):
            jobs.append(job)
        self.assertEqual(len(jobs), 1)
Exemplo n.º 12
0
def linuxLoadCronServices(service):
	from crontab import CronTab
	cron = CronTab()

	if service == "MPPatchLoader":
		print("Loading MPPatchLoader")

		cmd = MP_SRV_CONF + '/scripts/MPSUSPatchSync.py --config ' + MP_SRV_BASE + '/etc/patchloader.json'
		job  = cron.new(command=cmd)
		job.set_comment("MPPatchLoader")
		job.hour.every(8)
		job.enable()
		cron.write_to_user(user='******')

	if service == "MPSyncContent":
		print("Loading MPSyncContent")

		cmd = MP_SRV_CONF + '/scripts/MPSyncContent.py --config ' + MP_SRV_BASE + '/etc/syncContent.json'
		job  = cron.new(command=cmd)
		job.set_comment("MPSyncContent")
		job.minute.every(30)
		job.enable()
		cron.write_to_user(user='******')

	if service == "MPAVLoader":
		print("Loading MPAVLoader")

		cmd = MP_SRV_CONF + '/scripts/MPAVDefsSync.py --config ' + MP_SRV_BASE + '/etc/avconf.json'
		job  = cron.new(command=cmd)
		job.set_comment("MPAVLoader")
		job.hour.every(11)
		job.enable()
		cron.write_to_user(user='******')
Exemplo n.º 13
0
    def test_update(self):
        '''Update a job, It should update a job and return it'''
        added = self.schedule.get()[0]

        result = self.schedule.update({
            "id": added["id"],
            "enable": 1,
            "alias": "uptime",
            "command": "uptime && test_update",
            "schedule": "1 1 1 * *",
            "executer": True
        })

        self.assertNotEqual(result, None)

        self.assertDictEqual({
            "id": added["id"],
            "enable": 1,
            "alias": "uptime",
            "command": "uptime && test_update",
            "schedule": "1 1 1 * *",
            "executer": True,
            "comment": added["comment"]
        }, result)

        jobs = []
        cron = CronTab(user=True)
        for job in cron.find_comment(result["comment"]):
            jobs.append(job)
            self.assertEqual(job.slices, result["schedule"])
            self.assertEqual(job.command, result["command"])
        self.assertEqual(len(jobs), 1)
Exemplo n.º 14
0
def cleanScheduledPolicies(args):
    """
    Remove expired (or all) policies from crontab
    """
    debug = args.verbose
    config = ConfigLoader(args.config)
    setLoggingSystem(config, debug)
    logger.info('Start to remove old policies')
    cron = CronTab(user=True)
    jobList = []
    for job in cron:
        logger.debug('checking job command: %s', job.command)
        if job.command.startswith("export clientUserName") \
        and 'irule' in job.command:
            if (args.all):
                jobList.append(job)
            else:
                logger.debug('checking if the job is expired')
                schedule = job.schedule()
                datetime = schedule.get_next()
                if datetime.year > (date.today()).year:
                    logger.debug('removing the expired job')
                    jobList.append(job)

    for job in jobList:
        logger.info('removing the job ' + job.comment)
        cron.remove(job)

    cron.write_to_user(user=True)
    logger.info('Policies removed')
Exemplo n.º 15
0
    def run(self):
        """default method"""

        sess = Session()
        sender = self.req_obj.get('sender', '')

        #exctract sender email
        email = sender.split('/')[0]

        #find user profile by primary email
        profile = sess.query(Profile).filter(Profile.email == email).one()

        cron = CronTab('smarty')

        job = cron.new( command='/usr/bin/python %s/cron/cronjob.py --uuid=%s ' % ( ROBOT_DIR, profile.uuid ))
        logger.info('show cronjob %s' %  cron.render() )

        list = cron.find_command( '--uuid=%s' % profile.uuid )

        response = 'all my cronjobs'

        for job in list:
            response += "\n" + job

        if self.req_from == 'jabber':
            todo = { 'text' : response, 'jmsg' : response, 'type': 'response' }
            self.response = todo

        if self.req_from == 'julius':
            bang()
            todo = { 'say': response , 'text' : response ,'type': 'response' }
            self.response = say(self.request.replace('say', '').upper())

        return self.response
Exemplo n.º 16
0
def updateCrontabInterval():
  crontab = CronTab()
  crontabEntries = crontab.find_command(commandPath)
  if len(crontabEntries) > 1:
    raise Exception("more than one entry in the crontab!?")
  elif len(crontabEntries) == 1:
    updateIntervalString = downloadConfigUrl("http://%s/%s.config?type=updinterval" % (server, branchName))
    updateIntervalString = updateIntervalString[6:-4]
    updateInterval = int(updateIntervalString)
    if updateInterval < 5 or updateInterval > 480:
      raise Exception("received corrupt update interval")

    logInfo("update interval will be set to: " + str(updateInterval) + " mins")
    crontabEntry = crontabEntries[0]
    crontabEntry.clear()
    if updateInterval > 59:
      crontabEntry.hour().every(updateInterval / 60)
      crontabEntry.minute().on(random.randint(0, 59))
    else:
      crontabEntry.minute().every(updateInterval)

    logDebug("Will write new crontab '" + unicode(crontab.render()) + "'")
    crontab.write()
  else:
    logInfo("we are not installed in crontab, update interval will not be updated")
Exemplo n.º 17
0
class CompatTestCase(unittest.TestCase):
    """Test basic functionality of crontab."""
    def setUp(self):
        self.crontab = CronTab(tab=INITAL_TAB)

    def test_00_enabled(self):
        """Test Compatability Mode"""
        self.assertTrue(SunOS)

    def test_01_addition(self):
        """New Job Rendering"""
        job = self.crontab.new('addition1')
        job.minute.during(0, 3)
        job.hour.during(21, 23).every(1)
        job.dom.every(1)

        self.assertEqual(job.render(), '0,1,2,3 21,22,23 * * * addition1')

    def test_02_addition(self):
        """New Job Rendering"""
        job = self.crontab.new(command='addition2')

        job.minute.during(4, 9)
        job.hour.during(2, 10).every(2)
        job.dom.every(10)


        self.assertNotEqual(job.render(), '4-9 2-10/2 */3 * * addition2')
        self.assertEqual(job.render(), '4,5,6,7,8,9 2,4,6,8,10 1,11,21,31 * * addition2')
Exemplo n.º 18
0
		def linux_createCronJobs():
			#start cronjob
			cron_client = CronTab()
			iter =  cron_client.find_comment("Desktop Image Changer client")
			try:
				print "Client Cron Task Found"
				iter.next()
			except StopIteration:
				print 'Installing Client Cron Task'
				job = cron_client.new(scriptDirectory+ "/client.py dailyUpdate",
					comment="Desktop Image Changer client")
				job.every().dom()
				cron_client.write()

			cron_daemon = CronTab()
			iter =  cron_daemon.find_comment("Desktop Image Changer daemon")
			try:
				print "Daemon Cron Task Found"
				iter.next()
			except StopIteration:
				print 'Installing Daemon Cron Task'
				job = cron_daemon.new(scriptDirectory+ "/daemon.py &",
					comment="Desktop Image Changer daemon")
				job.every_reboot()
				cron_daemon.write()
Exemplo n.º 19
0
    def test_timezones(self):
        s = CronTab('0 9 13 3 * 2016')

        self.assertEqual(s.next(datetime.datetime(2016, 3, 13), default_utc=True), 32400)
        self.assertEqual(s.next(pytz.utc.localize(datetime.datetime(2016, 3, 13)), default_utc=True), 32400)

        self.assertEqual(s.next(pytz.timezone('US/Eastern').localize(datetime.datetime(2016, 3, 13))), 28800)
Exemplo n.º 20
0
def cleanScheduledPolicies(policyId, logger):
    """
    Remove policies from crontab

    @type  policy: policy object
    @param policy: The policy to be scheduled
    @type  logger: logger type
    @param logger: The logger
    """
    logger.info('Start to remove scheduled policies')
    cron = CronTab(user=True)
    jobList = []
    for job in cron:
        logger.debug('checking job command: %s', job.command)
        # find the scheduled cron jobs based on iRODS icommand keywords
        if job.command.startswith("export clientUserName") \
            and 'irule' in job.command:
            if policyId is not None: 
                if job.comment.startswith(policyId):
                    jobList.append(job)
            else:
                jobList.append(job)
    for job in jobList:
        logger.info('removing the job ' + job.comment)
        # remove the job
        cron.remove(job)
    # commit the change to the cron scheduler
    cron.write_to_user(user=True)
    logger.info('Policies removed')
def cron_thyself(original_arguments=[]):
    # Get the current time
    now = datetime.datetime.now()
    path, filename = get_script_path_and_name()
    from crontab import CronTab
    logging.info('Cron scheduling %s to happen in 24 hours (minute: %d hour: %d)' % (filename, now.minute, now.hour))
    cron = CronTab(user=True)
    jobs = cron.find_command(filename)
    jobs = [job for job in jobs]
    logging.debug('Existing cron jobs are: %s' % jobs)
    # If no job already exists, create one
    if not jobs:
        command = os.path.join(path, filename) + ' ' + ' '.join(original_arguments[1:])
        logging.info("No existing job detected. Creating a new one")
        job = cron.new(command, "Automatically log into hotspot every 24 hours.")
        # If we create a new job for this exact minute, then the job will run immediately after we create it.
        # Instead create the job for the past minute.
        minute = now.minute - 1
    else:
        if len(jobs) > 1:
            logging.warn("More than 1 cron lines for %s. Using the first one." % filename)
        job = jobs[0]
        minute = now.minute
    job.minute.on(minute)
    job.hour.on(now.hour)
    logging.info('Writing Cron job: %s' % job)
    cron.write()
Exemplo n.º 22
0
def shed_rm(request,shed_id):
     shed = Shed.objects.get(id=shed_id)
     tab = CronTab(user=settings.CRONTAB_USER)
     tab.remove_all(comment=shed.job.name)
     tab.write()
     shed.delete()
     return redirect ('/mailer/viewshed/')
Exemplo n.º 23
0
def cronHandler(data):
    if not data:
        return
    s = data.split(':')
    cronCommand = s[1].strip()
    if cronCommand not in ["on", "off"]:
        print("Cron command invalid, should be 'on' or 'off'. Command: %s" % cronCommand)
        return

    cronString = s[2].strip()
    if not CronSlices.is_valid(cronString):
        print("Cron time string invalid. Time string: %s" % cronString)
        return
    
    # Now we've validated the command, set a cron job
    cron_file = CronTab(user=True)
    it = cron_file.find_command(cronCommand)
    try:
        job = it.next()
        print("Found existing cron task for %s" % cronCommand)
    except StopIteration:
        job = cron_file.new(command="echo %s >> /tmp/test.txt" % cronCommand)
        print("Creating new cron task for %s" % cronCommand)

    job.setall(cronString)
    job.enable()
    cron_file.write()
Exemplo n.º 24
0
class CronTabs(list):
    """Singleton dictionary of all detectable crontabs"""
    _all = None
    _self = None

    def __new__(cls, *args, **kw):
        if not cls._self:
            cls._self = super(CronTabs, cls).__new__(cls, *args, **kw)
        return cls._self

    def __init__(self):
        if not self:
            for loc in KNOWN_LOCATIONS:
                self.add(*loc)

    def add(self, cls, *args):
        for tab in cls(*args, tabs=self):
            self.append(tab)
            self._all = None

    @property
    def all(self):
        """Return a CronTab object with all jobs (read-only)"""
        if self._all is None:
            self._all = CronTab(user=False)
            for tab in self:
                for job in tab:
                    if job.user is None:
                        job.user = tab.user or 'unknown'
                    self._all.append(job)
        return self._all
Exemplo n.º 25
0
def parse(file_name, aws_id, aws_secret):
    """
    Create a job in user's cron file for every machine schedule specified in json map
    """
    machines = json.loads(open(file_name).read())

    cron = CronTab(user=True)

    for machine in machines:
        # Don't create a line in cron if it already exists!

        for op in ['start', 'stop']:
            # Times defined in machine should be "start_time" or "stop_time"
            op_time = datetime.strptime(machine[op + '_time'], '%H:%M')

            # The op should conform to the options this program takes: start / stop
            job = cron.new(
                command='python {path} {op} {name} --id {aws_id} --secret {aws_secret} --region {region}'.format(
                    path=os.path.realpath(__file__),
                    op=op, name=machine['name'], aws_id=aws_id, aws_secret=aws_secret, region=machine['region']
                )
            )

            job.hour.on(op_time.hour)
            job.minute.on(op_time.minute)

    cron.write()
Exemplo n.º 26
0
    def _add_cron_tab(self, scheduled_time, object_id):

        LOG.debug(_("Add new cron tab at: %s") % scheduled_time )
        cron = CronTab()
        python_exec = (subprocess.check_output(['which','python'])).rstrip('\n')
        cwd = os.path.dirname(__file__)
        scheduler_path = cwd + "/timing-scheduler/run_scheduled_instance.py"
        config_file_path = self._get_config_file_path()
        config_file_params = " --config-file /etc/nova/nova.conf"
        if config_file_path:
            config_file_params = '--config-file ' + config_file_path
        LOG.debug(_("Config file params %s") % config_file_params )

        object_id_params = "--object_id %s" % object_id

        cmd = python_exec + " "+ \
              scheduler_path + " " + \
              config_file_params + " " + \
              object_id_params
        LOG.debug(_("Cron job cmd %s") % cmd )

        job = cron.new(command=cmd)
        job.hour.on(scheduled_time.hour)
        job.minute.on(scheduled_time.minute)
        job.day.on(scheduled_time.day)
        job.month.on(scheduled_time.month)

        cron.write()
Exemplo n.º 27
0
def cronjob():
	cron = CronTab()
	api_request = 'curl http://127.0.0.1:5000/api/reminder'
	job = cron.new(command = api_request, 
	    comment = "Reminding all users of jobs to be completed today.")
	job.setall('0 0 * * *')
	job.run()
Exemplo n.º 28
0
def unsetschedule(request):
  if not is_admin(request):
      return HTTPForbidden()
  cron_name = request.matchdict['name']
  cron  = CronTab(user=True)
  cron.remove_all(comment=cron_name)
  cron.write()
  return []
Exemplo n.º 29
0
def check_cron():
    # Check if cron exists if not add one
    # Writing job not working for unknown reason
    cron = CronTab(user="******")
    if cron.find_command(cron_command):
        return
    else:
        print "add '0 * * * * bash /etc/madari/hourly.sh' to crontab for root"
Exemplo n.º 30
0
def setup_crontab():
	job_command = 'sudo service nginx stop && /opt/certbot-auto renew && sudo service nginx start'
	user_crontab = CronTab(user=True)
	if job_command not in str(user_crontab):
		job  = user_crontab.new(command=job_command, comment="Renew lets-encrypt every month")
		job.every().month()
		job.enable()
		user_crontab.write()
Exemplo n.º 31
0
 def setUp(self):
     self.crontab = CronTab(tab="")
Exemplo n.º 32
0
    def test_04_zero_seq(self):
        tab = CronTab(tab="""
*/0 * * * * command
        """)
        self.assertEqual(len(tab), 0)
Exemplo n.º 33
0
def get_all_jobs():
    cron = CronTab(user=True)
    list = []
    for job in cron:
        list.append(job)
    return list
Exemplo n.º 34
0
                    curator_settings[operation].setdefault(
                        unit, {}).setdefault(value, []).append(project)
                else:
                    if unit.lower() == "hours":
                        logger.error(
                            'time unit "hours" is currently not supported due to our current index level granularity is in days'
                        )
                    else:
                        logger.error('an unknown time unit of ' + unit +
                                     ' was provided... Record skipped')
        else:
            logger.error('an unsupported or unknown operation ' + operation +
                         ' was provided... Record skipped')

my_cron = CronTab()
default_job = my_cron.new(command=default_command,
                          comment='Default generated job for curator')
default_job.every().day()

for operation in curator_settings:
    for unit in curator_settings[operation]:
        for value in curator_settings[operation][unit]:

            base_cmd = '/usr/bin/curator --loglevel ERROR ' + connection_info + ' ' + operation + ' indices --timestring %Y.%m.%d'
            tab_command = base_cmd + ' --older-than ' + str(
                value) + ' --time-unit ' + unit

            for project in curator_settings[operation][unit][value]:
                tab_command = tab_command + ' --prefix ' + project + '.'
Exemplo n.º 35
0
# DOCUMENTATION:
'''
Source:     https://stackabuse.com/scheduling-jobs-with-python-crontab/


'''

# Import Library
from crontab import CronTab

# Access Class Object
cron = CronTab()

# Create Function
script = 'test_crontab.py'

# Create A New Job
job = cron.new(command=script)
job.minute.every(1)
job.enable()
Exemplo n.º 36
0
def set_reminder(data):
   print(data.set_reminder) 
   cron = CronTab(user=True)
   job = cron.new(command='/usr/bin/env python3 test.py')
   job.minute.every(1)
   cron.write()
Exemplo n.º 37
0
from crontab import CronTab

cron = CronTab(user='******')
job = cron.new(command='python3 /home/syntizen/RAMU/workspace/email/sample.py')
job.minute.every(1)

cron.write()
Exemplo n.º 38
0
def limpiar_cron_job(actividad):
    cron = CronTab(user=True)
    cm = f"{PY} {settings.BASE_DIR}/manage.py closeactivity {actividad.pk} > /tmp/cronlog.txt 2>&1"
    cron.remove_all(command=cm)
    cron.write()
Exemplo n.º 39
0
#!/usr/bin/env python3

import datetime
from crontab import CronTab
import os.path

file = open('test.txt', 'a')
file.write('\nAccessed on ' + str(datetime.datetime.now()))
file.close

cron = CronTab(user=True)
for job in cron:
    print job
Exemplo n.º 40
0
from crontab import CronTab


cron = CronTab(user=True)
job = cron.new(command='python3 main.py')
job.minute.every(1)

cron.write()
Exemplo n.º 41
0
from model.sentiment import *
from stream import *
from autoStream import *
from utility import *
from config import *

# set Flask
app = Flask(__name__)

# set CNN model
global graph
graph = tf.get_default_graph()
vocab, tokenizer, max_length, model = load_variabels()

# Set crontab
cron = CronTab(user=curr_username)
cron.remove_all()
cron.write()

#-------------------- ROUTE View ---------------------------------------------------
"""
Route View berhubungan dengan untuk menampilkan templates
"""
# index route
"""
index untuk view yang baru
- menampilkan current_file
- status current_file apakah sudah diprediksi atau belum
- tombol prediksi
- tombol download
"""
Exemplo n.º 42
0
}

print(var.get(min(var)))

print("")

if (var.get(min(var))) == 'A':

    print("Optimaler Startzeitpunkt ist:")
    print(
        datetime.datetime.fromtimestamp(int(start) /
                                        1000).strftime('%d.%m.%Y %H:%M'))
    print("mit dem Durchschnitspreis von:")
    print(min(var))
    from crontab import CronTab
    cron = CronTab(user='******')
    cron.remove_all(comment='last3')
    cron.remove_all(comment='last3e')
    job = cron.new(command='/home/pi/Python/19E.sh', comment='last3')
    job.hour.on(h)
    job.minute.on(15)
    cron.write()

    job1 = cron.new(command='/home/pi/Python/19D.sh', comment='last3e')
    job1.hour.on(h9)
    job1.minute.on(1)
    cron.write()

elif (var.get(min(var))) == 'B':

    print("Optimaler Startzeitpunkt ist:")
Exemplo n.º 43
0
        # elif int(cmd) == 8:  # Migrate to a target process, currently WINDOWS ONLY **PLACEHOLDER** TODO IMPLEMENT THIS
        # targetPid = s.recv(BUFF_SIZE).decode()  # Target PID to migrate to

        elif int(cmd
                 ) == 8:  # Persistence, registry for Windows, Crontab for *nix
            if family == 'Windows':  # Do Windows persistence since we're on Windows
                exe = 'python ' + cwd + '\\' + sys.argv[0] + ' ' + sys.argv[
                    1] + ' ' + sys.argv[2]
                key = OpenKey(
                    HKEY_CURRENT_USER,
                    r"Software\Microsoft\Windows\CurrentVersion\Run", 0,
                    KEY_ALL_ACCESS)
                # Create our Run reg key entry using this script and our arguments
                SetValueEx(key, 'client', 0, REG_SZ, exe)
                key.Close()
            else:  # We're on a *nix system, try Cron
                exe = 'python ' + cwd + '/' + sys.argv[0] + ' ' + sys.argv[
                    1] + ' ' + sys.argv[2]
                cron = CronTab(user=user)
                reboot = '@reboot ' + exe  # Make our script run on reboot
                job = cron.new(command=exe)

                cron.write()
            s.send('Success'.encode())

        elif int(cmd) == 0:  # Exit
            exit()

        else:  # Not really distinct from if cmd == 0, but covers invalid command args. just exit
            exit()
Exemplo n.º 44
0
    def next(self):

        return math.ceil(CronTab.next(self)) * 1000
Exemplo n.º 45
0
    def __init__(self, crontab, callback):

        CronTab.__init__(self, crontab)

        PeriodicCallback.__init__(self, callback, self.next(),
                                  IOLoop.current())
Exemplo n.º 46
0
import os
from crontab import CronTab
from dotenv import load_dotenv
import sys
import requests
my_cron = CronTab(True)

dotenv_path = os.path.dirname(os.path.dirname(
    os.path.abspath(__file__))) + '/DjangoRestApi/.env'
load_dotenv(dotenv_path)

API_ENDPOINT = os.getenv('API_ENDPOINT')
WEB_CLIENT = os.getenv('WEB_CLIENT')
CLIENT_ID = os.getenv('CLIENT_ID')
CLIENT_SECRET = os.getenv('CLIENT_SECRET')
DOMAIN_API = os.environ.get('API_ENDPOINT')

username = sys.argv[1]
password = sys.argv[2]

data = {
    'username': username,
    'password': password,
}
r = requests.post(API_ENDPOINT + '/v1/auth/login-admin', data=data)
data = r.json()

token = data['data']['access_token']
bearer = data['data']['token_type']

headers = {
Exemplo n.º 47
0
from crontab import CronTab

PATH_TO_SYSTEM_TAB_FILE = "data.tab"
cron_obj = CronTab(tabfile=PATH_TO_SYSTEM_TAB_FILE)

job_first = cron_obj.new(command="python3 path/to/rest/api/server.py")
job_first.hour.every(6)

job_second = cron_obj.new(command="python3 path/to/rest/api/client.py")
job_second.every(3).hours()

for job in cron_obj:
    print(job)

cron_obj.write()
Exemplo n.º 48
0
import mock

try:
    from StringIO import StringIO
except ImportError:
    from io import StringIO

from django.core.management import call_command
from django.test import TestCase
from django.core.management.base import CommandError
from crontab import CronTab
from kronos.settings import KRONOS_BREADCRUMB
from kronos import registry, load


crontab = CronTab('')

def get_crontab(*args, **kwargs):
    return crontab


class TestCase(TestCase):

    def setUp(self):
        load()
        crontab.remove_all()

    # @patch('subprocess.Popen')
    # def test_unintalltasks(self, mock):
    #     """Test uninstalling tasks with the ``uninstalltasks`` command."""
    #     mock.return_value = Mock(
Exemplo n.º 49
0
 def setUp(self):
     self.crontab = CronTab(tab=INITIAL_TAB)
Exemplo n.º 50
0
        xfce4panel_process.kill()
        time.sleep(5)
        log.info("Start xfce4-panel again.")
        log.info("xfce4-panel started with exit code: " + str(subprocess.call("xfce4-panel", shell=True)))

elif args.mode == "schedule":
    DEFAULT_CRON = "0 * * * *"  # every hour
    
    from crontab import CronTab, CronSlices

    cron_schedule = DEFAULT_CRON

    script_file_path = os.path.realpath(__file__)
    command = sys.executable + " '" + script_file_path + "' check> /proc/1/fd/1 2>/proc/1/fd/2"

    cron = CronTab(user=True)

    # remove all other tasks
    cron.remove_all(command=command)

    job = cron.new(command=command)
    if CronSlices.is_valid(cron_schedule):
        log.info("Scheduling cron check xfdesktop task with with cron: " + cron_schedule)
        job.setall(cron_schedule)
        job.enable()
        cron.write()
    else:
        log.info("Failed to schedule check xfdesktop. Cron is not valid.")

    log.info("Running cron jobs:")
    for job in cron:
""" Collecting Deployments configured for Scaling """
import os
import pathlib
import json
import logging
import shutil
import pykube
import re
import urllib.request
import boto3
import time
from datetime import datetime
from crontab import CronTab

EXECUTION_TIME = 'datetime.datetime.now().strftime("%d-%m-%Y %H:%M UTC")'
crontab_instance = CronTab(user="******")


def create_job_directory():
    """ This directory will hold the temp python scripts to execute the scaling jobs """
    temp__dir = '/tmp/scaling_jobs'
    if os.path.isdir(temp__dir):
        shutil.rmtree(temp__dir)
    pathlib.Path(temp__dir).mkdir(parents=True, exist_ok=True)


def clear_cron():
    """ This is needed so that if any one removes his scaling action
          it should not be trigger again """
    crontab_instance.remove_all(comment="Scheduling_Jobs")
Exemplo n.º 52
0
class EnvTestCase(unittest.TestCase):
    """Test vixie cron user addition."""
    def setUp(self):
        self.crontab = CronTab(tab=INITIAL_TAB)

    def test_01_consistancy(self):
        """Read in crontab and write out the same"""
        self.assertEqual(INITIAL_TAB, str(self.crontab))

    def test_02_top_vars(self):
        """Whole file env variables"""
        crontab = CronTab(tab="SHELL=dash\n")
        self.assertEqual(str(crontab), "SHELL=dash\n")
        self.assertEqual(crontab.env['SHELL'], 'dash')
        crontab.env['SHELL'] = 'bash'
        self.assertEqual(str(crontab), "SHELL=bash\n")
        self.assertEqual(crontab.env['SHELL'], 'bash')

    def test_03_get_job_var(self):
        """Test each of the job env structures"""
        for job, expected in zip(self.crontab, [
            {
                'PERSONAL_VAR': 'bar',
                'CRON_VAR': 'fork'
            },
            {
                'PERSONAL_VAR': 'bar',
                'CRON_VAR': 'spoon'
            },
            {
                'PERSONAL_VAR': 'bar',
                'CRON_VAR': 'knife'
            },
            {
                'PERSONAL_VAR': 'bar',
                'CRON_VAR': 'knife',
                'SECONDARY': 'fork'
            },
        ]):
            self.assertEqual(OrderedDict(job.env.all()), expected)

    def test_04_set_job_var(self):
        """Test that variables set are applied correctly"""
        self.crontab[1].env['CRON_VAR'] = 'javlin'
        self.assertEqual(self.crontab[1].env.all(), {
            'PERSONAL_VAR': 'bar',
            'CRON_VAR': 'javlin'
        })
        self.crontab[2].env['CRON_VAR'] = 'javlin'
        self.assertEqual(self.crontab[2].env.all(), {
            'PERSONAL_VAR': 'bar',
            'CRON_VAR': 'javlin'
        })
        self.assertEqual(self.crontab[3].env['PERSONAL_VAR'], 'bar')
        self.assertEqual(self.crontab[3].env.all(), {
            'PERSONAL_VAR': 'bar',
            'CRON_VAR': 'javlin',
            'SECONDARY': 'fork'
        })

        self.crontab.env['PERSONAL_VAR'] = 'foo'
        self.assertEqual(self.crontab[2].env.all(), {
            'PERSONAL_VAR': 'foo',
            'CRON_VAR': 'javlin'
        })

        self.crontab.env['CRON_VAR'] = 'fork'
        self.assertEqual(self.crontab[0].env.all(), {
            'PERSONAL_VAR': 'foo',
            'CRON_VAR': 'fork'
        })

        self.assertEqual(
            str(self.crontab), """PERSONAL_VAR=foo
CRON_VAR=fork

34 12 * * * eat_soup

CRON_VAR=javlin
35 12 * * * eat_salad

36 12 * * * eat_icecream

SECONDARY=fork
38 12 * * * eat_steak
""")

    def test_05_no_env(self):
        """Test that we get an error asking for no var"""
        with self.assertRaises(KeyError):
            self.crontab.env['BLUE_BOTTLE']
        with self.assertRaises(KeyError):
            self.crontab[0].env['RED_BOTTLE']

    def test_06_env_access(self):
        cron = CronTab(tab="""
MYNAME='Random'

* * * * * echo "first: $MYNAME"
* * * * * echo "second: $MYNAME"
* * * * * echo "third: $MYNAME"
        """)
        for job in cron:
            self.assertEqual(job.env['MYNAME'], "Random")

    def test_07_mutated_dict(self):
        """Test when the ordered dict is changed during loop"""
        cron = CronTab(tab="""
ALL='all'
ABCD='first'
* * * * * echo "first"
        """)

    def test_08_space_quotes(self):
        """Test that spaces and quotes are handled correctly"""
        cron = CronTab(tab="""
A=   123   
B="   123   "
C='   123   '
D=  " 123 "  
E= 1 2 3 
""")
        self.assertEqual(cron.env['A'], '123')
        self.assertEqual(cron.env['B'], '   123   ')
        self.assertEqual(cron.env['C'], '   123   ')
        self.assertEqual(cron.env['D'], ' 123 ')
        self.assertEqual(cron.env['E'], '1 2 3')

        self.assertEqual(
            str(cron), """A=123
B="   123   "
C="   123   "
D=" 123 "
E="1 2 3"

""")

    def test_09_delete_middle(self):
        """Test that a delete doesn't remove vars"""
        self.crontab.remove_all(command='eat_icecream')
        self.crontab.remove_all(command='eat_soup')
        self.assertEqual(
            str(self.crontab), """PERSONAL_VAR=bar
CRON_VAR=spoon
35 12 * * * eat_salad


CRON_VAR=knife
SECONDARY=fork
38 12 * * * eat_steak
""")
Exemplo n.º 53
0
from crontab import CronTab

if __name__ == '__main__':
    #tab = CronTab(user='******',fake_tab='True')
    tab = CronTab('yangxu')
    cmd = 'python test.py'
    #cron_job = tab.new(command = cmd, comment='main command')
    cron_job = tab.new(command=cmd)
    cron_job.minutes.every(1)
    cron_job.enable()
    print 'done'
    #cron_job.hour.every(3)
    #tab.write()
    #print tab.render()
Exemplo n.º 54
0
from crontab import CronTab

cron = CronTab(tabfile='filename.tab')
job = cron.new(command='echo "123"')
job.minute.every(1)
cron.write()
Exemplo n.º 55
0
from crontab import CronTab

cron = CronTab(user='******')
job = cron.new(command='python3 process.py')
job.minute.every(10)

cron.write()
Exemplo n.º 56
0
import sys, os
sys.path.append("./")
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "server.settings")
import django
django.setup()
from opencsp.models import Server
from crontab import CronTab

cron = CronTab(user=True)
cron.remove_all(comment='checkserver')

scripts_path = os.path.dirname(os.path.abspath(__file__))

for server in Server.objects.filter(server_active=True):
    command = os.path.join(scripts_path,
                           'check_for_new.py {0}'.format(server.pk))
    #print 'Install', command
    job = cron.new(command=command, comment='checkserver')
    job.setall('* * * * *')
    job.enable(True)

cron.write()
#print cron.render()
Exemplo n.º 57
0
class EveryTestCase(unittest.TestCase):
    """Test basic functionality of crontab."""
    def setUp(self):
        self.crontab = CronTab(
            tabfile=os.path.join(TEST_DIR, 'data', 'test.tab'))

    def test_00_minutes(self):
        """Every Minutes"""
        for job in self.crontab:
            job.every(3).minutes()
            self.assertEqual(job.slices.clean_render(), '*/3 * * * *')
            job.minutes.every(5)
            self.assertEqual(job.slices.clean_render(), '*/5 * * * *')

    def test_01_hours(self):
        """Every Hours"""
        for job in self.crontab:
            job.every(3).hours()
            self.assertEqual(job.slices.clean_render(), '0 */3 * * *')

    def test_02_dom(self):
        """Every Day of the Month"""
        for job in self.crontab:
            job.every(3).dom()
            self.assertEqual(job.slices.clean_render(), '0 0 */3 * *')

    def test_03_single(self):
        """Every Single Hour"""
        for job in self.crontab:
            job.every().hour()
            self.assertEqual(job.slices.clean_render(), '0 * * * *')

    def test_04_month(self):
        """Every Month"""
        for job in self.crontab:
            job.every(3).months()
            self.assertEqual(job.slices.clean_render(), '0 0 1 */3 *')

    def test_05_dow(self):
        """Every Day of the Week"""
        for job in self.crontab:
            job.every(3).dow()
            self.assertEqual(job.slices.clean_render(), '0 0 * * */3')

    def test_06_year(self):
        """Every Year"""
        for job in self.crontab:
            job.every().year()
            self.assertEqual(job.slices.render(), '@yearly')
            self.assertEqual(job.slices.clean_render(), '0 0 1 1 *')
            self.assertRaises(ValueError, job.every(2).year)

    def test_07_reboot(self):
        """Every Reboot"""
        for job in self.crontab:
            job.every_reboot()
            self.assertEqual(job.slices.render(), '@reboot')
            self.assertEqual(job.slices.clean_render(), '* * * * *')

    def test_08_newitem(self):
        """Every on New Item"""
        job = self.crontab.new(command='hourly')
        job.every().hour()
        self.assertEqual(job.slices.render(), '@hourly')
        job = self.crontab.new(command='firstly')
        job.hours.every(2)
        self.assertEqual(job.slices.render(), '* */2 * * *')
Exemplo n.º 58
0
 def setUp(self):
     self.crontab = CronTab(
         tabfile=os.path.join(TEST_DIR, 'data', 'test.tab'))
 def test_crontab(self) -> None:
     self.assertEqual(
         CronTab("@daily").matchers, self.periodic.crontab.matchers)
Exemplo n.º 60
0
#
import os
from crontab import CronTab

#
# Setup the cron command to run from the current user's omniEngine directory.
#
homeDir = os.environ['HOME']
engineCommand = 'python {0}/omniEngine/omniEngine.py >> {1}/omniEngine/logs/omniEngine.log'.format(
    homeDir, homeDir)
engineComment = 'Update OmniEngne DB using RPC'

#
# Access the current users' CronTab
#
cron = CronTab(user=True)

# Look for existing job
found = cron.find_command('omniEngine.py')
job = next(found, None)
if job is not None:
    # If existing job, clear all fields and set correct values
    print "Found existing job: "
    print job
    job.clear()
    job.set_command(engineCommand)
    job.set_comment(engineComment)
else:
    # If no existing job, set up job from scratch
    print "Adding job."
    job = cron.new(command=engineCommand, comment='load Tx into DB using RPC')