def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) webdav = orm['services.WebDAV'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='webdav') svc = svc[0] if svc.exists() else None if svc: cs.set('service.webdav.enable', svc.srv_enable) if webdav.webdav_protocol == 'http': protocol = ['HTTP'] elif webdav.webdav_protocol == 'https': protocol = ['HTTPS'] else: protocol = ['HTTP', 'HTTPS'] cs.set('service.webdav.protocol', protocol) cs.set('service.webdav.http_port', webdav.webdav_tcpport or 8080) cs.set('service.webdav.https_port', webdav.webdav_tcpportssl or 8081) try: if webdav.webdav_password: from freenasUI.middleware.notifier import notifier cs.set('service.webdav.password', notifier().pwenc_decrypt(webdav.webdav_password)) except: pass cs.set('service.webdav.authentication', webdav.webdav_htauth.upper())
def forwards(self, orm): # Skip for install time, we only care for upgrades here if "FREENAS_INSTALL" in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) nfs = orm["services.NFS"].objects.all()[0] svc = orm["services.services"].objects.filter(srv_service="nfs") svc = svc[0] if svc.exists() else None if svc: cs.set("service.nfs.enable", svc.srv_enable) cs.set("service.nfs.servers", nfs.nfs_srv_servers) cs.set("service.nfs.udp", nfs.nfs_srv_udp) cs.set("service.nfs.nonroot", nfs.nfs_srv_allow_nonroot) cs.set("service.nfs.v4", nfs.nfs_srv_v4) cs.set("service.nfs.v4_kerberos", nfs.nfs_srv_v4_krb) if nfs.nfs_srv_bindip: cs.set("service.nfs.bind_addresses", nfs.nfs_srv_bindip.split(",")) if nfs.nfs_srv_mountd_port: cs.set("service.nfs.mountd_port", nfs.nfs_srv_mountd_port) if nfs.nfs_srv_rpcstatd_port: cs.set("service.nfs.rpcstatd_port", nfs.nfs_srv_rpcstatd_port) if nfs.nfs_srv_rpclockd_port: cs.set("service.nfs.rpclockd_port", nfs.nfs_srv_rpclockd_port)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) snmp = orm['services.SNMP'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='snmp') svc = svc[0] if svc.exists() else None if svc: cs.set('service.snmp.enable', svc.srv_enable) cs.set('service.snmp.location', snmp.snmp_location or None) cs.set('service.snmp.contact', snmp.snmp_contact or None) cs.set('service.snmp.community', snmp.snmp_community or 'public') cs.set('service.snmp.v3', snmp.snmp_v3) cs.set('service.snmp.v3_username', snmp.snmp_v3_username or None) cs.set('service.snmp.v3_password', snmp.snmp_v3_password or None) cs.set('service.snmp.v3_auth_type', snmp.snmp_v3_authtype or 'SHA') cs.set('service.snmp.v3_privacy_protocol', snmp.snmp_v3_privproto or 'AES') cs.set('service.snmp.v3_privacy_passphrase', snmp.snmp_v3_privpassphrase or None) cs.set('service.snmp.auxiliary', snmp.snmp_options or None)
def main(self): if len(sys.argv) != 2: print("Invalid number of arguments", file=sys.stderr) sys.exit(errno.EINVAL) key = sys.argv[1] logging.basicConfig(file=sys.stdout, level=logging.DEBUG) try: self.datastore = get_default_datastore() self.conn = Client() self.conn.connect("127.0.0.1") self.conn.login_service("task.{0}".format(os.getpid())) self.conn.enable_server() self.conn.rpc.register_service_instance("taskproxy", self.service) task = self.conn.call_sync("task.checkin", key) module = imp.load_source("plugin", task["filename"]) setproctitle.setproctitle("task executor (tid {0})".format(task["id"])) try: self.instance = getattr(module, task["class"])(DispatcherWrapper(self.conn), self.datastore) self.instance.configstore = ConfigStore(self.datastore) self.running.set() result = self.instance.run(*task["args"]) except BaseException, err: print("Task exception: {0}".format(str(err)), file=sys.stderr) traceback.print_exc(file=sys.stderr) self.put_status("FAILED", exception=err) else:
def main(self): if len(sys.argv) != 2: print("Invalid number of arguments", file=sys.stderr) sys.exit(errno.EINVAL) key = sys.argv[1] logging.basicConfig(file=sys.stdout, level=logging.DEBUG) try: self.datastore = get_default_datastore() self.conn = Client() self.conn.connect('127.0.0.1') self.conn.login_service('task.{0}'.format(os.getpid())) self.conn.enable_server() self.conn.rpc.register_service_instance('taskproxy', self.service) task = self.conn.call_sync('task.checkin', key) module = imp.load_source('plugin', task['filename']) setproctitle.setproctitle('task executor (tid {0})'.format( task['id'])) try: self.instance = getattr(module, task['class'])( DispatcherWrapper(self.conn), self.datastore) self.instance.configstore = ConfigStore(self.datastore) self.running.set() result = self.instance.run(*task['args']) except BaseException, err: print("Task exception: {0}".format(str(err)), file=sys.stderr) traceback.print_exc(file=sys.stderr) self.put_status('FAILED', exception=err) else:
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) ddns = orm['services.DynamicDNS'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='dynamicdns') svc = svc[0] if svc.exists() else None if svc: cs.set('service.dyndns.enable', svc.srv_enable) if ddns.ddns_provider: cs.set('service.dyndns.provider', ddns.ddns_provider) if ddns.ddns_ipserver: cs.set('service.dyndns.ipserver', ddns.ddns_ipserver) if ddns.ddns_domain: cs.set('service.dyndns.domains', ddns.ddns_domain.split(',')) cs.set('service.dyndns.username', ddns.ddns_username) try: pwd = notifier().pwenc_decrypt(ddns.ddns_password) except: pwd = '' cs.set('service.dyndns.password', pwd) if ddns.ddns_updateperiod: cs.set('service.dyndns.update_period', ddns.ddns_updateperiod) if ddns.ddns_fupdateperiod: cs.set('service.dyndns.force_update_period', ddns.ddns_fupdateperiod) if ddns.ddns_options: cs.set('service.dyndns.auxiliary', ddns.ddns_options)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) ups = orm['services.UPS'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='ups') svc = svc[0] if svc.exists() else None if svc: cs.set('service.ups.enable', svc.srv_enable) cs.set('service.ups.mode', ups.ups_mode.upper()) cs.set('service.ups.identifier', ups.ups_identifier) cs.set('service.ups.remote_host', ups.ups_remotehost) cs.set('service.ups.remote_port', ups.ups_remoteport) cs.set('service.ups.driver', ups.ups_driver.split('$')[0]) cs.set('service.ups.driver_port', ups.ups_port) cs.set('service.ups.auxiliary', ups.ups_options or None) cs.set('service.ups.description', ups.ups_description or None) cs.set('service.ups.shutdown_mode', ups.ups_shutdown.upper()) cs.set('service.ups.shutdown_timer', ups.ups_shutdowntimer) cs.set('service.ups.monitor_user', ups.ups_monuser) cs.set('service.ups.monitor_password', ups.ups_monpwd) cs.set('service.ups.auxiliary_users', ups.ups_extrausers or None) cs.set('service.ups.monitor_remote', ups.ups_rmonitor) cs.set('service.ups.email_notify', ups.ups_emailnotify) cs.set('service.ups.email_recipients', ups.ups_toemail or []) cs.set('service.ups.email_subject', ups.ups_subject) cs.set('service.ups.powerdown', ups.ups_powerdown)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) settings = orm['system.Settings'].objects.order_by('-id')[0] cs.set('system.language', settings.stg_language) cs.set('system.timezone', settings.stg_timezone) cs.set('system.console.keymap', settings.stg_kbdmap) cs.set('system.syslog_server', settings.stg_syslogserver) listen = [] if settings.stg_guiaddress: listen.append(settings.stg_guiaddress) if settings.stg_guiv6address: listen.append('[{0}]'.format(settings.stg_guiv6address)) cs.set('service.nginx.http.enable', settings.stg_guiprotocol in ('http', 'httphttps')) cs.set('service.nginx.https.enable', settings.stg_guiprotocol in ('https', 'httphttps')) cs.set('service.nginx.listen', listen) cs.set('service.nginx.http.port', settings.stg_guiport) cs.set('service.nginx.http.redirect_https', settings.stg_guihttpsredirect) cs.set('service.nginx.https.port', settings.stg_guihttpsport)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() return # To be fixed for share in orm['sharing.CIFS_Share'].objects.all(): ds.insert('shares', { 'description': share.cifs_comment, 'enabled': True, }) for share in orm['sharing.AFP_Share'].objects.all(): ds.insert('shares', { 'enabled': True, }) for share in orm['sharing.NFS_Share'].objects.all(): ds.insert('shares', { 'enabled': True, }) for share in orm['sharing.WebDAV_Share'].objects.all(): ds.insert('shares', { 'enabled': True, })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) afp = orm['services.AFP'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='afp') svc = svc[0] if svc.exists() else None if svc: cs.set('service.afp.enable', svc.srv_enable) cs.set('service.afp.guest_enable', afp.afp_srv_guest) if afp.afp_srv_guest_user: cs.set('service.afp.guest_user', afp.afp_srv_guest_user) if afp.afp_srv_bindip: cs.set('service.afp.bind_addresses', afp.afp_srv_bindip) cs.set('service.afp.connections_limit', afp.afp_srv_connections_limit) cs.set('service.afp.homedir_enable"', afp.afp_srv_homedir_enable) if afp.afp_srv_homedir: cs.set('service.afp.homedir_path', afp.afp_srv_homedir) if afp.afp_srv_homename: cs.set('service.afp.homedir_name', afp.afp_srv_homename) if afp.afp_srv_dbpath: cs.set('service.afp.dbpath', afp.afp_srv_dbpath) if afp.afp_srv_global_aux: cs.set('service.afp.auxiliary', afp.afp_srv_global_aux)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() for disk in orm['storage.Disk'].objects.all(): dev = self.identifier_to_device(disk.disk_identifier) if not dev: print("Identifier to device failed for {0}, skipping".format(disk.disk_identifier)) continue newident = self.device_to_identifier(dev, serial=(disk.disk_serial or None)) if not newident: print("Failed to convert {0} to id, skipping".format(dev)) ds.insert('disks', { 'id': newident, 'serial': disk.disk_serial, 'description': disk.disk_description, 'smart': disk.disk_togglesmart, 'smart_options': disk.disk_smartoptions, 'standby_mode': None if disk.disk_hddstandby == 'Always On' else int(disk.disk_hddstandby), 'acoustic_level': disk.disk_acousticlevel.upper(), 'apm_mode': None if disk.disk_advpowermgmt == 'Disabled' else int(disk.disk_advpowermgmt), }) disk.disk_identifier = newident disk.save()
def main(self): if len(sys.argv) != 2: print("Invalid number of arguments", file=sys.stderr) sys.exit(errno.EINVAL) key = sys.argv[1] logging.basicConfig(level=logging.DEBUG) self.datastore = get_default_datastore() self.configstore = ConfigStore(self.datastore) self.conn = Client() self.conn.connect('unix:') self.conn.login_service('task.{0}'.format(os.getpid())) self.conn.enable_server() self.conn.rpc.register_service_instance('taskproxy', self.service) self.conn.call_sync('task.checkin', key) setproctitle.setproctitle('task executor (idle)') while True: try: task = self.task.get() setproctitle.setproctitle('task executor (tid {0})'.format(task['id'])) if task['debugger']: sys.path.append('/usr/local/lib/dispatcher/pydev') import pydevd host, port = task['debugger'] pydevd.settrace(host, port=port, stdoutToServer=True, stderrToServer=True) module = imp.load_source('plugin', task['filename']) setproctitle.setproctitle('task executor (tid {0})'.format(task['id'])) try: self.instance = getattr(module, task['class'])(DispatcherWrapper(self.conn), self.datastore) self.instance.configstore = self.configstore self.running.set() result = self.instance.run(*task['args']) except BaseException as err: print("Task exception: {0}".format(str(err)), file=sys.stderr) traceback.print_exc(file=sys.stderr) self.put_status('FAILED', exception=err) else: self.put_status('FINISHED', result=result) except RpcException as err: print("RPC failed: {0}".format(str(err)), file=sys.stderr) sys.exit(errno.EBADMSG) except socket.error as err: print("Cannot connect to dispatcher: {0}".format(str(err)), file=sys.stderr) sys.exit(errno.ETIMEDOUT) if task['debugger']: import pydevd pydevd.stoptrace() setproctitle.setproctitle('task executor (idle)')
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() testtype_map = { 'L': 'LONG', 'S': 'SHORT', 'C': 'CONVEYANCE', 'O': 'OFFLINE', } for smart in orm['tasks.SMARTTest'].objects.all(): day_of_week = [] for w in smart.smarttest_dayweek.split(','): try: day_of_week.append(WEEKDAYS[int(w) - 1]) except: pass if not day_of_week: day_of_week = '*' else: day_of_week = ','.join(day_of_week) testtype = testtype_map.get(smart.smarttest_type, 'LONG') disk_ids = [] for disk in smart.smarttest_disks.all(): if not disk.disk_identifier: continue disk_ids.append(disk.disk_identifier) if not disk_ids: continue ds.insert('schedulerd.runs', { 'id': 'smarttest_{0}'.format(smart.id), 'description': 'SMART Test {0}'.format(testtype), 'name': 'disks.parallel_test', 'args': [disk_ids, testtype], 'enabled': True, 'schedule': { 'year': '*', 'month': smart.smarttest_month, 'week': '*', 'day_of_week': day_of_week, 'day': smart.smarttest_daymonth, 'hour': smart.smarttest_hour, 'minute': 0, 'second': 0, } })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() for g in orm['account.bsdGroups'].objects.filter(bsdgrp_builtin=False): ds.insert('groups', { 'id': g.bsdgrp_gid, 'name': g.bsdgrp_group, 'bultin': False, 'sudo': g.bsdgrp_sudo, }) for u in orm['account.bsdUsers'].objects.all(): groups = [] for bgm in orm['account.bsdGroupMembership'].objects.filter(bsdgrpmember_user=u): groups.append(bgm.bsdgrpmember_group.bsdgrp_gid) if u.bsdusr_builtin: user = ds.get_by_id('users', u.bsdusr_uid) if user is None: continue user.update({ 'email': u.bsdusr_email, 'unixhash': u.bsdusr_unixhash, 'smbhash': u.bsdusr_smbhash, 'groups': groups, }) ds.upsert('users', user['id'], user) continue ds.insert('users', { 'id': u.bsdusr_uid, 'username': u.bsdusr_username, 'unixhash': u.bsdusr_unixhash, 'smbhash': u.bsdusr_smbhash, 'group': u.bsdusr_group.bsdgrp_gid, 'home': u.bsdusr_home, 'shell': u.bsdusr_shell, 'full_name': u.bsdusr_full_name, 'builtin': False, 'email': u.bsdusr_email, 'password_disabled': u.bsdusr_password_disabled, 'locked': u.bsdusr_locked, 'sudo': u.bsdusr_sudo, 'sshpubkey': bsdusr_sshpubkey(u), 'groups': groups, }) ds.collection_record_migration('groups', 'freenas9_migration') ds.collection_record_migration('users', 'freenas9_migration')
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() for vol in orm['storage.Volume'].objects.all(): ds.insert('volumes', { 'id': vol.vol_guid, 'name': vol.vol_name, 'type': 'zfs', 'mountpoint': '/mnt/{0}'.format(vol.vol_name), 'attributes': {}, })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) lldp = orm['services.LLDP'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='lldp') svc = svc[0] if svc.exists() else None if svc: cs.set('service.lldp.enable', svc.srv_enable) cs.set('service.lldp.save_description', lldp.lldp_intdesc) cs.set('service.lldp.country_code', lldp.lldp_country or None) cs.set('service.lldp.location', lldp.lldp_location or None)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) ssh = orm['services.SSH'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='ssh') svc = svc[0] if svc.exists() else None if svc: cs.set('service.ssh.enable', svc.srv_enable) cs.set('service.ssh.port', ssh.ssh_tcpport) cs.set('service.ssh.permit_root_login', ssh.ssh_rootlogin) cs.set('service.ssh.allow_password_auth', ssh.ssh_passwordauth) cs.set('service.ssh.allow_port_forwarding', ssh.ssh_tcpfwd) cs.set('service.ssh.compression', ssh.ssh_compression) cs.set('service.ssh.sftp_log_level', ssh.ssh_sftp_log_level) cs.set('service.ssh.sftp_log_facility', ssh.ssh_sftp_log_facility) cs.set('service.ssh.auxiliary', ssh.ssh_options or None) cs.set('service.ssh.keys.host.private', ssh.ssh_host_key) cs.set('service.ssh.keys.host.public', ssh.ssh_host_key_pub) cs.set('service.ssh.keys.dsa.private', ssh.ssh_host_dsa_key or None) cs.set('service.ssh.keys.dsa.public', ssh.ssh_host_dsa_key_pub or None) if ssh.ssh_host_dsa_key_cert_pub: cs.set('service.ssh.keys.dsa.certificate', ssh.ssh_host_dsa_key_cert_pub) cs.set('service.ssh.keys.ecdsa.private', ssh.ssh_host_ecdsa_key or None) cs.set('service.ssh.keys.ecdsa.public', ssh.ssh_host_ecdsa_key_pub or None) if ssh.ssh_host_ecdsa_key_cert_pub: cs.set('service.ssh.keys.ecdsa.certificate', ssh.ssh_host_ecdsa_key_cert_pub) cs.set('service.ssh.keys.ed25519.private', ssh.ssh_host_ed25519_key or None) cs.set('service.ssh.keys.ed25519.public', ssh.ssh_host_ed25519_key_pub or None) if ssh.ssh_host_ed25519_key_cert_pub: cs.set('service.ssh.keys.ed25519.certificate', ssh.ssh_host_ed25519_key_cert_pub) cs.set('service.ssh.keys.rsa.private', ssh.ssh_host_rsa_key or None) cs.set('service.ssh.keys.rsa.public', ssh.ssh_host_rsa_key_pub or None) if ssh.ssh_host_rsa_key_cert_pub: cs.set('service.ssh.keys.rsa.certificate', ssh.ssh_host_rsa_key_cert_pub)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) iscsi = orm['services.iSCSITargetGlobalConfiguration'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='iscsi') svc = svc[0] if svc.exists() else None if svc: cs.set('service.iscsi.enable', svc.srv_enable) cs.set('service.iscsi.base_name', iscsi.iscsi_basename) cs.set('service.iscsi.isns_servers', iscsi.iscsi_isns_servers) cs.set('service.iscsi.pool_space_threshold', iscsi.iscsi_pool_avail_threshold) # iSCSI Portals iscsi_portals = orm['services.iSCSITargetPortal'].objects.all() for p in iscsi_portals: ds.insert('iscsi.portals', { 'id': 'pg{0}'.format(p.id), 'tag': p.iscsi_target_portal_tag, 'description': p.iscsi_target_portal_comment, 'discovery_auth_group': 'ag{0}'.format(p.iscsi_target_portal_discoveryauthgroup), 'listen': [{'address': i.iscsi_target_portalip_ip, 'port': i.iscsi_target_portalip_port} for i in p.ips.all()] }) # iSCSI Targets iscsi_targets = orm['services.iSCSITarget'].objects.all() for t in iscsi_targets: ds.insert('iscsi.targets', { 'id': t.iscsi_target_name, 'portal_group': 'default', # XXX: Needs to pass proper portal group 'auth_group': 'no-authentication', # XXX: Needs to pass proper auth group 'description': t.iscsi_target_alias, 'extents': [] })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) smartd = orm['services.SMART'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='smartd') svc = svc[0] if svc.exists() else None if svc: cs.set('service.smartd.enable', svc.srv_enable) cs.set('service.smartd.interval', smartd.smart_interval) cs.set('service.smartd.power_mode', smartd.smart_powermode.upper()) cs.set('service.smartd.temp_difference', smartd.smart_difference or None) cs.set('service.smartd.temp_informational', smartd.smart_informational or None) cs.set('service.smartd.temp_critical', smartd.smart_critical or None)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) tftp = orm['services.TFTP'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='tftp') svc = svc[0] if svc.exists() else None if svc: cs.set('service.tftp.enable', svc.srv_enable) cs.set('service.tftp.path', tftp.tftp_directory or None) cs.set('service.tftp.allow_new_files', tftp.tftp_newfiles) cs.set('service.tftp.port', tftp.tftp_port) cs.set('service.tftp.username', tftp.tftp_username) cs.set('service.tftp.umask', tftp.tftp_umask) cs.set('service.tftp.auxiliary', tftp.tftp_options or None)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() # If we are migrating delete all entries in mongodb # because we don't know what the user changed/has in 9.3 for ntp in ds.query('ntpservers'): ds.delete('ntpservers', ntp['id']) for ntp in orm['system.NTPServer'].objects.all(): ds.insert('ntpservers', { 'address': ntp.ntp_address, 'burst': ntp.ntp_burst, 'iburst': ntp.ntp_iburst, 'prefer': ntp.ntp_prefer, 'minpoll': ntp.ntp_minpoll, 'maxpoll': ntp.ntp_maxpoll, })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() for cron in orm['tasks.CronJob'].objects.all(): day_of_week = [] for w in cron.cron_dayweek.split(','): try: day_of_week.append(WEEKDAYS[int(w) - 1]) except: pass if not day_of_week: day_of_week = '*' else: day_of_week = ','.join(day_of_week) ds.insert('schedulerd.runs', { 'id': 'cronjob_{0}_{1}'.format(cron.cron_user, cron.id), 'description': cron.cron_description, 'name': 'calendar_tasks.command', 'args': [cron.cron_user, cron.cron_command], 'enabled': cron.cron_enabled, 'schedule': { 'year': '*', 'month': cron.cron_month, 'week': '*', 'day_of_week': day_of_week, 'day': cron.cron_daymonth, 'hour': cron.cron_hour, 'minute': cron.cron_minute, 'second': 0, } })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) rsyncd = orm['services.Rsyncd'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='rsync') svc = svc[0] if svc.exists() else None if svc: cs.set('service.rsyncd.enable', svc.srv_enable) cs.set('service.rsyncd.port', rsyncd.rsyncd_port) cs.set('service.rsyncd.auxiliary', rsyncd.rsyncd_auxiliary) for rmod in orm['services.RsyncMod'].objects.all(): if rmod.rsyncmod_path == 'ro': mode = 'READONLY' elif rmod.rsyncmod_path == 'wo': mode = 'WRITEONLY' else: mode = 'READWRITE' ds.insert('rsyncd-module', { 'name': rmod.rsyncmod_name, 'description': rmod.rsyncmod_comment or None, 'path': rmod.rsyncmod_path, 'mode': mode, 'max_connections': rmod.rsyncmod_maxconn or None, 'user': rmod.rsyncmod_user, 'group': rmod.rsyncmod_group, 'hosts_allow': rmod.rsyncmod_hostsallow or None, 'hosts_deny': rmod.rsyncmod_hostsdeny or None, 'auxiliary': rmod.rsyncmod_auxiliary or None, })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() for scrub in orm['storage.Scrub'].objects.all(): day_of_week = [] for w in scrub.scrub_dayweek.split(','): try: day_of_week.append(WEEKDAYS[int(w) - 1]) except: pass if not day_of_week: day_of_week = '*' else: day_of_week = ','.join(day_of_week) ds.insert('schedulerd.runs', { 'id': 'scrub_{0}_{1}'.format(scrub.scrub_volume.vol_name, scrub.id), 'description': scrub.scrub_description, 'name': 'zfs.pool.scrub', 'args': [scrub.scrub_volume.vol_name, scrub.scrub_threshold], 'enabled': scrub.scrub_enabled, 'schedule': { 'year': '*', 'month': scrub.scrub_month, 'week': '*', 'day_of_week': day_of_week, 'day': scrub.scrub_daymonth, 'hour': scrub.scrub_hour, 'minute': scrub.scrub_minute, 'second': 0, } })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() for tun in orm['system.Tunable'].objects.all(): if tun.tun_type == 'sysctl': _type = 'SYSCTL' elif tun.tun_type == 'loader': _type = 'LOADER' else: _type = 'RC' ds.insert('tunables', { 'var': tun.tun_var, 'value': tun.tun_value, 'type': _type, 'comment': tun.tun_comment, 'enabled': tun.tun_enabled, })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) email = orm['system.Email'].objects.order_by('-id')[0] cs.set('mail.from', email.em_fromemail) cs.set('mail.server', email.em_outgoingserver) cs.set('mail.port', email.em_port) encryption = 'PLAIN' if email.em_security in ('ssl', 'tls'): encryption = email.em_security.upper() cs.set('mail.encryption', encryption) cs.set('mail.auth', email.em_smtp) cs.set('mail.user', email.em_user) cs.set('mail.pass', email.em_pass)
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) adv = orm['system.Advanced'].objects.order_by('-id')[0] cs.set('system.console.cli', adv.adv_consolemenu) cs.set('system.console.screensaver', adv.adv_consolescreensaver) cs.set('system.serial.console', adv.adv_serialconsole) cs.set('system.serial.port', adv.adv_serialport) cs.set('system.serial.speed', int(adv.adv_serialspeed)) cs.set('service.powerd.enable', adv.adv_powerdaemon) cs.set('system.swapondrive', adv.adv_swapondrive) cs.set('system.autotune', adv.adv_autotune) cs.set('system.debug.kernel', adv.adv_debugkernel) cs.set('system.upload_crash', adv.adv_uploadcrash) cs.set('system.motd', adv.adv_motd) cs.set('system.boot_scrub_internal', adv.adv_boot_scrub) user = ds.query('users', ('username', '=', adv.adv_periodic_notifyuser), single=True) if user: cs.set('system.periodic.notify_user', user['id']) root = ds.query('users', ('id', '=', 0), single=True) if root: root['attributes'].update({ 'gui_messages_footer': adv.adv_consolemsg, 'gui_traceback': adv.adv_traceback, 'gui_advancedmode': adv.adv_advancedmode, }) ds.update('users', root['id'], root)
def forwards(self, orm): ds = get_default_datastore() cs = ConfigStore(ds) # Migrate global network configuration globalconf = orm.GlobalConfiguration.objects.order_by("-id")[0] cs.set('system.hostname', globalconf.gc_hostname + '.' + globalconf.gc_domain) cs.set('network.gateway.ipv4', globalconf.gc_ipv4gateway or None) cs.set('network.gateway.ipv6', globalconf.gc_ipv6gateway or None) cs.set('network.http_proxy', globalconf.gc_httpproxy or None) cs.set('network.dns.addresses', list(filter(None, [ globalconf.gc_nameserver1 or None, globalconf.gc_nameserver2 or None, globalconf.gc_nameserver3 or None, ]))) cs.set('network.netwait.enable', globalconf.gc_netwait_enabled) cs.set('network.netwait.addresses', globalconf.gc_netwait_ip.split()) # Migrate hosts database for line in globalconf.gc_hosts.split('\n'): line = line.strip() if not line: continue items = line.split() name = items.pop(0) for addr in items: ds.upsert('network.hosts', name, { 'address': addr }) # Migrate VLAN interfaces configuration unit = 0 for i in orm.VLAN.objects.all(): ds.insert('network.interfaces', { 'id': 'vlan{0}'.format(unit), 'type': 'VLAN', 'enabled': True, 'description': i.vlan_description, 'vlan': { 'parent': i.vlan_pint, 'tag': i.vlan_tag } }) unit += 1 # Migrate LAGG interfaces configuration unit = 0 for i in orm.LAGGInterface.objects.all(): ds.insert('network.interfaces', { 'id': 'lagg{0}'.format(unit), 'type': 'LAGG', 'enabled': True, 'lagg': { 'protocol': LAGG_PROTOCOL_MAP[i.lagg_protocol], 'ports': [m.int_interface for m in i.lagg_interfacemembers_set.all()] } }) unit += 1 # Migrate IP configuration autoconfigure = True for i in orm.Interfaces.objects.all(): autoconfigure = False aliases = [] iface = ds.get_by_id('network.interfaces', i.int_interface) if not iface: iface = { 'enabled': True, } iface.update({ 'description': i.int_name, 'dhcp': i.int_dhcp, 'aliases': aliases }) if i.int_ipv4address: aliases.append({ 'type': 'INET', 'address': str(i.int_ipv4address), 'netmask': int(i.int_v4netmaskbit) }) if i.int_ipv6address: aliases.append({ 'type': 'INET6', 'address': str(i.int_ipv6address), 'netmask': int(i.int_v6netmaskbit) }) for alias in i.alias_set.all(): if alias.alias_v4address: aliases.append({ 'type': 'INET', 'address': str(alias.alias_v4address), 'netmask': int(alias.alias_v4netmaskbit) }) if alias.alias_v6address: aliases.append({ 'type': 'INET6', 'address': str(alias.alias_v6address), 'netmask': int(alias.alias_v6netmaskbit) }) m = re.search(r'mtu (\d+)', i.int_options) if m: iface['mtu'] = int(m.group(1)) m = re.search(r'media (\w+)', i.int_options) if m: iface['media'] = m.group(1) m = re.search(r'mediaopt (\w+)', i.int_options) if m: opt = m.group(1) if opt in MEDIAOPT_MAP: iface['mediaopts'] = [MEDIAOPT_MAP[opt]] # Try to read capabilities for k, v in CAPABILITY_MAP.items(): if '-{0}'.format(k) in i.int_options: l = iface.setdefault('capabilities', {}).setdefault('del', []) l += v elif k in i.int_options: l = iface.setdefault('capabilities', {}).setdefault('add', []) l += v ds.upsert('network.interfaces', i.int_interface, iface) # If there are no interfaces, let it autoconfigure cs.set('network.autoconfigure', autoconfigure) # Migrate static routes for i in orm.StaticRoute.objects.all(): try: net = ipaddress.ip_network(i.sr_destination) except ValueError as e: print("Invalid network {0}: {1}".format(i.sr_destination, e)) continue ds.insert('network.routes', { 'network': str(net.network_address), 'netmask': net.prefixlen, 'gateway': i.sr_gateway, 'type': 'INET' }) ds.collection_record_migration('network.interfaces', 'freenas9_migration') ds.collection_record_migration('network.routes', 'freenas9_migration') ds.collection_record_migration('network.hosts', 'freenas9_migration')
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) def migrate_cert(certs): id_uuid_map = {} signedby = [] for obj in certs: if obj.cert_type == 0x1: _type = 'CA_EXISTING' elif obj.cert_type == 0x2: _type = 'CA_INTERNAL' elif obj.cert_type == 0x4: _type = 'CA_INTERMEDIATE' elif obj.cert_type == 0x8: _type = 'CERT_EXISTING' elif obj.cert_type == 0x10: _type = 'CERT_INTERNAL' else: _type = 'CERT_CSR' cert = { 'type': _type, 'name': obj.cert_name, 'certificate': obj.cert_certificate, 'privatekey': obj.cert_privatekey, 'csr': obj.cert_CSR, 'key_length': obj.cert_key_length, 'digest_algorithm': obj.cert_digest_algorithm, 'lifetime': obj.cert_lifetime, 'country': obj.cert_country, 'state': obj.cert_state, 'city': obj.cert_city, 'organization': obj.cert_organization, 'email': obj.cert_email, 'common': obj.cert_common, 'serial': obj.cert_serial, } pkey = ds.insert('crypto.certificates', cert) id_uuid_map[obj.id] = pkey if obj.cert_signedby is not None: signedby.append(obj.id) return id_uuid_map, signedby def migrate_signedby(model, id_uuid_map, signedby, ca_map): for id in signedby: cobj = model.objects.get(id=id) pkey = id_uuid_map.get(id) if pkey is None: continue cert = ds.get_by_id('crypto.certificates', pkey) if cobj.cert_signedby is None: continue signedby = ca_map.get(cobj.cert_signedby.id) if signedby is None: continue cert['signedby'] = signedby ds.update('crypto.certificates', pkey, cert) id_uuid_map, signedby = migrate_cert(orm['system.CertificateAuthority'].objects.order_by('cert_signedby')) migrate_signedby(orm['system.CertificateAuthority'], id_uuid_map, signedby, id_uuid_map) cert_id_uuid_map, cert_signedby = migrate_cert(orm['system.Certificate'].objects.order_by('cert_signedby')) migrate_signedby(orm['system.Certificate'], cert_id_uuid_map, cert_signedby, id_uuid_map) settings = orm['system.Settings'].objects.order_by('-id')[0] if settings.stg_guicertificate: uuid = cert_id_uuid_map.get(settings.stg_guicertificate.id) if uuid: cs.set('service.nginx.https.certificate', uuid) ds.collection_record_migration('crypto.certificates', 'freenas9_migration')
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() for task in orm['storage.Task'].objects.all(): replication = orm['storage.Replication'].objects.filter(repl_filesystem=task.task_filesystem).exists() pool = task.task_filesystem.split('/')[0] lifetime = '{0}{1}'.format(task.task_ret_count, task.task_ret_unit[0]) day_of_week = [] for w in task.task_byweekday.split(','): try: day_of_week.append(WEEKDAYS[int(w) - 1]) except: pass if not day_of_week: day_of_week = '*' else: day_of_week = ','.join(day_of_week) begin_end = '{0}-{1}'.format(task.task_begin.hour, task.task_end.hour) if task.task_interval < 60: week = '*' day = '*' hour = begin_end minute = '*/{0}'.format(task.task_interval) elif task.task_interval < 1440: week = '*' day = '*' hour = '{0}/{1}'.format(begin_end, int(task.task_interval / 60)) minute = 0 elif task.task_interval == 1440: week = '*' day = '*' hour = task.task_begin.hour minute = 0 else: week = '*/{0}'.format(int(task.task_interval / 10080)) day = '*' hour = task.task_begin.hour minute = 0 ds.insert('schedulerd.runs', { 'id': 'snapshot{0}'.format(task.id), 'description': 'Periodic Snapshot Task: {0}'.format(task.task_filesystem), 'name': 'volume.snapshot_periodic', 'args': [pool, task.task_filesystem, task.task_recursive, lifetime, 'auto', replication], 'enabled': task.task_enabled, 'schedule': { 'year': '*', 'month': '*', 'week': week, 'day_of_week': day_of_week, 'day': day, 'hour': hour, 'minute': minute, 'second': 0, } })
def forwards(self, orm): # Skip for install time, we only care for upgrades here if 'FREENAS_INSTALL' in os.environ: return ds = get_default_datastore() cs = ConfigStore(ds) ftp = orm['services.FTP'].objects.all()[0] svc = orm['services.services'].objects.filter(srv_service='ftp') svc = svc[0] if svc.exists() else None if svc: cs.set('service.ftp.enable', svc.srv_enable) tls_options = [] if ftp.ftp_tls_opt_allow_client_renegotiations: tls_options.append('ALLOW_CLIENT_RENEGOTIATIONS') if ftp. ftp_tls_opt_allow_dot_login: tls_options.append('ALLOW_DOT_LOGIN') if ftp.ftp_tls_opt_allow_per_user: tls_options.append('ALLOW_PER_USER') if ftp.ftp_tls_opt_common_name_required: tls_options.append('COMMON_NAME_REQUIRED') if ftp.ftp_tls_opt_enable_diags: tls_options.append('ENABLE_DIAGNOSTICS') if ftp.ftp_tls_opt_export_cert_data: tls_options.append('EXPORT_CERTIFICATE_DATA') if ftp.ftp_tls_opt_no_cert_request: tls_options.append('NO_CERTIFICATE_REQUEST') if ftp.ftp_tls_opt_no_empty_fragments: tls_options.append('NO_EMPTY_FRAGMENTS') if ftp.ftp_tls_opt_no_session_reuse_required: tls_options.append('NO_SESSION_REUSE_REQUIRED') if ftp.ftp_tls_opt_stdenvvars: tls_options.append('STANDARD_ENV_VARS') if ftp.ftp_tls_opt_dns_name_required: tls_options.append('DNS_NAME_REQUIRED') if ftp.ftp_tls_opt_ip_address_required: tls_options.append('IP_ADDRESS_REQUIRED') cs.set('service.ftp.port', ftp.ftp_port) cs.set('service.ftp.max_clients', ftp.ftp_clients) if ftp.ftp_ipconnections: cs.set('service.ftp.ip_connections', ftp.ftp_ipconnections) cs.set('service.ftp.login_attempt', ftp.ftp_loginattempt) cs.set('service.ftp.timeout', ftp.ftp_timeout) cs.set('service.ftp.root_login', ftp.ftp_rootlogin) cs.set('service.ftp.only_anonymous', ftp.ftp_onlyanonymous) if ftp.ftp_anonpath: cs.set('service.ftp.anonymous_path', ftp.ftp_anonpath) cs.set('service.ftp.only_local', ftp.ftp_onlylocal) cs.set('service.ftp.display_login', ftp.ftp_banner) cs.set('service.ftp.filemask', ftp.ftp_filemask) cs.set('service.ftp.dirmask', ftp.ftp_dirmask) cs.set('service.ftp.fxp', ftp.ftp_fxp) cs.set('service.ftp.resume', ftp.ftp_resume) cs.set('service.ftp.chroot', ftp.ftp_defaultroot) cs.set('service.ftp.ident', ftp.ftp_ident) cs.set('service.ftp.reverse_dns', ftp.ftp_reversedns) cs.set('service.ftp.masquerade_address', ftp.ftp_masqaddress) if ftp.ftp_passiveportsmin: cs.set('service.ftp.passive_ports_min', ftp.ftp_passiveportsmin) if ftp.ftp_passiveportsmax: cs.set('service.ftp.passive_ports_max', ftp.ftp_passiveportsmax) if ftp.ftp_localuserbw: cs.set('service.ftp.local_up_bandwidth', ftp.ftp_localuserbw) if ftp.ftp_localuserdlbw: cs.set('service.ftp.local_down_bandwidth', ftp.ftp_localuserdlbw) if ftp.ftp_anonuserbw: cs.set('service.ftp.anon_up_bandwidth', ftp.ftp_anonuserbw) if ftp.ftp_anonuserdlbw: cs.set('service.ftp.anon_down_bandwidth', ftp.ftp_anonuserdlbw) cs.set('service.ftp.tls', ftp.ftp_tls) if tls_options: cs.set('service.ftp.tls_options', tls_options) cs.set('service.ftp.auxiliary', ftp.ftp_options)