Example #1
0
def getSchedulerDetail():
    try:
        remoteDict = Json_evaluation.getJsonByKey(filename=__syncFile__,
                                                  key="susServer",
                                                  path=__path__)
        Sync.getSchedulerStatus(remoteDict, path=__path__, logPath=__logPath__)
        return jsonify(
            Json_evaluation.readJSON(path=__path__,
                                     filename=__schedulerTimeStampFile__))
    except Exception as e:
        return str(e), 500
Example #2
0
    def run_button(self, event):
        isit = None
        r = Parser().read("repo_path")
        os.chdir(r)
        Globals.TERM.set_background_saturation(0.3)
        Globals.TERM.fork_command('clear')
        Globals.TERM.fork_command('bash')
        if Globals.checkClobber.get_active() == True:
            isit = True
            if not os.path.exists("%s/.repo" % r):
                RepoHelper().run_no_repo_found()
                Globals.TERM.set_background_saturation(1.0)
                Globals.TERM.fork_command('clear')
                return

            Globals.TERM.feed_child('make clobber\n')

        if Globals.checkSync.get_active() == True:
            isit = True
            Sync().run()

        if Globals.checkCompile.get_active() == True:
            isit = True
            Compile().run()

        if isit == None:
            self.ResetTerm()
Example #3
0
 def syncronize(self):
     vRef = self.beepRef.fileName
     v1 = self.faceVideo.fileName
     if not ((vRef == '') | (v1 == '')):
         sync = Sync(vRef, v1)
         syncedFaceVid = sync.get_synced_video()
         if syncedFaceVid != '':
             self.faceVideo.setMediaPlayer(syncedFaceVid)
             self.video360.setMediaPlayer(self.video360.fileName)
             QMessageBox.about(self, 'video Annotator',
                               'Sync process is done!')
         else:
             QMessageBox.about(self, 'video Annotator',
                               'Sync process failed. Please try again.')
     else:
         QMessageBox.about(self, 'video Annotator',
                           'Please upload the videos first!')
Example #4
0
    def __build_screen(self, sc, canvas, show_hour=False):
        directory = None
        try:
            isCopy = self.__config_get(sc, "CopyOf")
            directory = self.sync_directory + isCopy + "/"
        except:
            directory = self.sync_directory + sc + "/"
            self.__prepare_dir(directory)
            try:
                fileList = self.__config_get(sc, 'FileList').splitlines()
                for f in fileList:
                    if f not in self.files_list:
                        self.files_list.append(f)
                        self.sync_services.append(
                            Sync(f, directory, self.sync_delay))
            except:
                pass

        try:
            align = self.__config_get(sc, "Alignement")
        except:
            align = self.screen_align

        try:
            ratio = self.__config_get(sc, "Ratio")
        except:
            ratio = self.screen_ratio

        try:
            delay = self.configuration.get(sc, "Delay")
        except:
            delay = self.screen_delay

        try:
            rotat = self.__config_get(sc, "Rotation")
        except:
            rotat = self.screen_rotation

        screen = Screen(canvas, delay, directory, align, ratio, rotat,
                        show_hour)
        return screen
Example #5
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Sync import Sync

sync = Sync()
sync.sync_follow_delete_yuming()
Example #6
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Sync import Sync

sync = Sync()
sync.sync_follow_yuming()
Example #7
0
#!/usr/bin/python3
# -*- coding: utf-8 -*-

from PasswordManager import CtSesam
from PasswordSettingsManager import PasswordSettingsManager
from Sync import Sync
import getpass
import zlib

if __name__ == "__main__":
    syncer = Sync("https://ersatzworld.net/ctpwdgen-server/", 'inter', 'op')
    remote_blob = syncer.pull()
    master_password = getpass.getpass(prompt='Masterpasswort: ')
    settings_manager = PasswordSettingsManager()
    write_to_file = False
    remote_update_needed = False
    try:
        settings_manager.load_settings_from_file(master_password)
        remote_update_needed = settings_manager.update_from_export_data(
            master_password, remote_blob)
        write_to_file = True
    except zlib.error:
        print(
            "Falsches Masterpasswort. Es wurden keine Einstellungen geladen.")
    domain = input('Domain: ')
    while len(domain) < 1:
        print(
            'Bitte gib eine Domain an, für die das Passwort generiert werden soll.'
        )
        domain = input('Domain: ')
    setting_found = False
 def create_sync(self):
     """
     creates a sync object.
     """
     self.sync = Sync(self.server_address, self.username, self.password, self.certificate_file.name)
class SyncManager:
    """
    Synchronization manager. This initializes and stores settings and handles the Sync object.
    """
    def __init__(self):
        self.server_address = ""
        self.username = ""
        self.password = ""
        self.certificate = ""
        self.certificate_file = None
        self.sync = None

    def __del__(self):
        if self.certificate_file:
            self.certificate_file.close()

    def get_binary_sync_settings(self):
        """
        returns packed sync settings

        :return: binary settings
        :rtype: bytes
        """
        if self.sync:
            return Packer.compress(json.dumps({
                "server-address": self.server_address,
                "username": self.username,
                "password": self.password,
                "certificate": self.certificate
            }).encode('utf-8'))
        else:
            return b''

    def load_binary_sync_settings(self, data):
        """
        loads sync settings

        :param bytes data: packed json data of sync settings
        """
        settings_dict = json.loads(str(Packer.decompress(data), encoding='utf-8'))
        if "server-address" in settings_dict and \
           "username" in settings_dict and \
           "password" in settings_dict and \
           "certificate" in settings_dict:
            self.server_address = settings_dict["server-address"]
            self.username = settings_dict["username"]
            self.password = settings_dict["password"]
            self.certificate = settings_dict["certificate"]
            if self.certificate_file:
                self.certificate_file.close()
            self.certificate_file = NamedTemporaryFile()
            self.certificate_file.write(self.certificate.encode('utf-8'))
            self.certificate_file.seek(0)
            self.create_sync()
        else:
            print("Sync settings konnten nicht geladen werden.")

    def ask_for_sync_settings(self):
        """
        Ask the user for sync settings: Asks for server-URL, username and password.
        """
        print("Bitte geben Sie die Einstellungen für Ihren Synchronisations-Server an...")
        self.server_address = input("URL: ")
        self.username = input("Benutzername: ")
        self.password = input("Passwort: ")
        line = input("Zertifikat im .pem-Format (beenden mit einer Leerzeile): ")
        while len(line) > 0:
            self.certificate += line + "\n"
            line = input("")
        self.certificate += line
        if self.certificate_file:
            self.certificate_file.close()
        self.certificate_file = NamedTemporaryFile()
        self.certificate_file.write(self.certificate.encode('utf-8'))
        self.certificate_file.seek(0)
        self.create_sync()
        print("Teste die Verbindung...")
        if len(self.sync.pull()) > 0:
            print("Verbindung erfolgreich getestet.")
        else:
            print("Es konnte keine Verbindung aufgebaut werden.")

    def create_sync(self):
        """
        creates a sync object.
        """
        self.sync = Sync(self.server_address, self.username, self.password, self.certificate_file.name)

    def pull(self):
        """
        pulls data from the sync server. Returns an empty string if no connection is possible.

        :return: pulled base64 data
        :rtype: str
        """
        if self.sync:
            return self.sync.pull()
        else:
            return False, ''

    def push(self, data):
        """
        pushes data to the sync server. If the push fails an error message is displayed.

        :param str data: base64 data
        """
        if self.sync:
            if not self.sync.push(data):
                print("Synchronisation fehlgeschlagen.")
        else:
            print("Sie haben keine gültigen Einstellungen für den sync server.")
 def test_pull_empty_request(self):
     sync = Sync("https://ersatzworld.net/ctpwdgen-server/", 'inter', 'op', 'file.pem')
     status, blob = sync.pull()
     self.assertTrue(status)
     self.assertEqual('', blob)
 def test_pull(self):
     sync = Sync("https://ersatzworld.net/ctpwdgen-server/", 'inter', 'op', 'file.pem')
     status, blob = sync.pull()
     self.assertTrue(status)
     self.assertEqual(str(b64encode(b'Test'), encoding='utf-8'), blob)
Example #12
0
# -*- coding: utf-8 -*-
from Sync import Sync
import threading

SYNC_THREAD = Sync(True)
KEYS = [
    "karni", "bar", "ely", "shaffir", "ronny", "baranetz", "aviv", "doyev",
    "tamar", "sadot", "inbar", "rousso", "ori", "sharabi"
]

VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]


def set_thread(key, value):
    Sync.set_value(SYNC_THREAD, key, value)


def delete_thread(key):
    Sync.delete_value(SYNC_THREAD, key)


def get_thread(key):
    print Sync.get_value(SYNC_THREAD, key)


def create_set_threads(num, key, value):
    set_threads = []
    for i in range(num):
        set_threads.append(
            threading.Thread(target=set_thread(key[i], value[i])))
    return set_threads
Example #13
0
def set_thread(key, value):
    Sync.set_value(SYNC_THREAD, key, value)
#!/usr/bin/python3
# -*- coding: utf-8 -*-

from PasswordManager import CtSesam
from PasswordSettingsManager import PasswordSettingsManager
from Sync import Sync
import getpass
import zlib

if __name__ == "__main__":
    syncer = Sync("https://ersatzworld.net/ctpwdgen-server/", 'inter', 'op')
    remote_blob = syncer.pull()
    master_password = getpass.getpass(prompt='Masterpasswort: ')
    settings_manager = PasswordSettingsManager()
    write_to_file = False
    remote_update_needed = False
    try:
        settings_manager.load_settings_from_file(master_password)
        remote_update_needed = settings_manager.update_from_export_data(master_password, remote_blob)
        write_to_file = True
    except zlib.error:
        print("Falsches Masterpasswort. Es wurden keine Einstellungen geladen.")
    domain = input('Domain: ')
    while len(domain) < 1:
        print('Bitte gib eine Domain an, für die das Passwort generiert werden soll.')
        domain = input('Domain: ')
    setting_found = False
    if domain in [dom[:len(domain)] for dom in settings_manager.get_domain_list()]:
        if domain in settings_manager.get_domain_list():
            setting_found = True
            print("Die Einstellungen für " + domain + " wurden geladen.")
Example #15
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Sync import Sync

sync = Sync()
sync.sync_null_date_yuming()
sync.sync_near_expiration_date_yuming()
Example #16
0
File: logic.py Project: m0dts/GB3KM
id_timer = timer_id()  #15min '900seconds
carousel_timer = repeating_timer(15)  #15sec
lcd_timer = repeating_timer(3)  #3sec
user_ident_timer = onetime_timer(60)  #60sec
k_timer = onetime_timer(2)  #
osd_timer = loop_timer(5, 1)  #
pip_timer = repeating_timer(20)  #
tx_hang_timer = onetime_timer(30)  # tx hang timer 5min 300

# General class inits
videoswitch = videoswitch()  #HDMI video switch
enc = encoder("192.168.88.249", "m0dts", "xxxxx")  #hdmi encoder
comms485 = Serial_485()  #serial for comms
display = display(display_type)  #display
io = IO()  #i2c io extender board
sync = Sync()  #analog sync
osd = OSD()  #OSD MAX7456
dtmf = DTMF()
time.sleep(1)

setup()

# Timers
carousel_timer.interval = 15  #15sec
k_timer.interval = 2
lcd_timer.interval = 8
user_ident_timer.interval = 10
pip_timer.interval = config["VideoSwitchSettings"]["pip_toggle_time"]

#class init
enc.disable_osd_image(0)
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Sync import Sync



sync = Sync()
sync.sync_follow_yuming()
Example #18
0
def get_thread(key):
    print Sync.get_value(SYNC_THREAD, key)
Example #19
0
def delete_thread(key):
    Sync.delete_value(SYNC_THREAD, key)
 def test_push(self):
     sync = Sync("https://ersatzworld.net/ctpwdgen-server/", 'inter', 'op', 'file.pem')
     self.assertTrue(sync.push(str(b64encode(b'Test'), encoding='utf-8')))