def save(self): try: jc = JailsConfiguration.objects.order_by("-id")[0] except Exception as e: raise MiddlewareError(e.message) if not jc.jc_path: raise MiddlewareError(_("No jail root configured.")) jail_host = self.cleaned_data.get('jail_host') jail_ipv4 = self.cleaned_data.get('jail_ipv4') jail_ipv6 = self.cleaned_data.get('jail_ipv6') jail_flags = WARDEN_FLAGS_NONE jail_create_args = {} jail_create_args['jail'] = jail_host w = Warden() if self.cleaned_data['jail_32bit']: jail_flags |= WARDEN_CREATE_FLAGS_32BIT # if self.cleaned_data['jail_source']: # jail_flags |= WARDEN_CREATE_FLAGS_SRC # if self.cleaned_data['jail_ports']: # jail_flags |= WARDEN_CREATE_FLAGS_PORTS if self.cleaned_data['jail_vanilla']: jail_flags |= WARDEN_CREATE_FLAGS_VANILLA template_create_args = {} jail_type = self.cleaned_data['jail_type'] template = JailTemplate.objects.get(jt_name=jail_type) template_create_args['nick'] = template.jt_name template_create_args['tar'] = template.jt_url template_create_args['flags'] = WARDEN_TEMPLATE_FLAGS_CREATE | \ WARDEN_TEMPLATE_CREATE_FLAGS_NICK | \ WARDEN_TEMPLATE_CREATE_FLAGS_TAR template = None template_list_flags = {} template_list_flags['flags'] = WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break createfile = "/var/tmp/.templatecreate" if not template: try: cf = open(createfile, "a+") cf.close() w.template(**template_create_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) if os.path.exists(createfile): os.unlink(createfile) return template_list_flags = {} template_list_flags['flags'] = WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break if not template: self.errors['__all__'] = self.error_class( [_('Unable to find template!')]) return if template['type'] == 'Linux': jail_flags |= WARDEN_CREATE_FLAGS_LINUXJAIL if template['arch'] == 'i386': jail_flags |= WARDEN_CREATE_FLAGS_32BIT jail_flags |= WARDEN_CREATE_FLAGS_TEMPLATE jail_create_args['template'] = template_create_args['nick'] if jail_ipv4: jail_flags |= WARDEN_CREATE_FLAGS_IPV4 jail_create_args['ipv4'] = jail_ipv4 if jail_ipv6: jail_flags |= WARDEN_CREATE_FLAGS_IPV6 jail_create_args['ipv6'] = jail_ipv6 jail_flags |= WARDEN_CREATE_FLAGS_LOGFILE jail_flags |= WARDEN_CREATE_FLAGS_SYSLOG jail_create_args['logfile'] = self.logfile jail_create_args['flags'] = jail_flags createfile = "/var/tmp/.jailcreate" try: cf = open(createfile, "a+") cf.close() w.create(**jail_create_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) if os.path.exists(createfile): os.unlink(createfile) return if os.path.exists(createfile): os.unlink(createfile) for key in ('jail_bridge_ipv4', 'jail_bridge_ipv6', 'jail_defaultrouter_ipv4', 'jail_defaultrouter_ipv6', 'jail_mac'): jail_set_args = {} jail_set_args['jail'] = jail_host jail_flags = WARDEN_FLAGS_NONE val = self.cleaned_data.get(key, None) if val: if key == 'jail_bridge_ipv4': jail_flags |= WARDEN_SET_FLAGS_BRIDGE_IPV4 jail_set_args['bridge-ipv4'] = val elif key == 'jail_bridge_ipv6': jail_flags |= WARDEN_SET_FLAGS_BRIDGE_IPV6 jail_set_args['bridge-ipv6'] = val elif key == 'jail_defaultrouter_ipv4': jail_flags |= WARDEN_SET_FLAGS_DEFAULTROUTER_IPV4 jail_set_args['defaultrouter-ipv4'] = val elif key == 'jail_defaultrouter_ipv6': jail_flags |= WARDEN_SET_FLAGS_DEFAULTROUTER_IPV6 jail_set_args['defaultrouter-ipv6'] = val elif key == 'jail_mac': jail_flags |= WARDEN_SET_FLAGS_MAC jail_set_args['mac'] = val jail_set_args['flags'] = jail_flags try: w.set(**jail_set_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return jail_nat = self.cleaned_data.get('jail_nat', None) jail_vnet = self.cleaned_data.get('jail_vnet', None) jail_set_args = {} jail_set_args['jail'] = jail_host jail_flags = WARDEN_FLAGS_NONE if jail_nat: jail_flags |= WARDEN_SET_FLAGS_NAT_ENABLE else: jail_flags |= WARDEN_SET_FLAGS_NAT_DISABLE jail_set_args['flags'] = jail_flags try: w.set(**jail_set_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return jail_set_args = {} jail_set_args['jail'] = jail_host jail_flags = WARDEN_FLAGS_NONE if jail_vnet: # XXXX if NOT LINUX XXXX (revisit this) if (not self.cleaned_data['jail_32bit']): jail_flags |= WARDEN_SET_FLAGS_VNET_ENABLE else: jail_flags |= WARDEN_SET_FLAGS_VNET_DISABLE jail_set_args['flags'] = jail_flags try: w.set(**jail_set_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return if self.cleaned_data['jail_autostart']: try: w.auto(jail=jail_host) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return try: w.start(jail=jail_host) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return
def save(self): jc = self.jc if not jc.jc_path: raise MiddlewareError(_("No jail root configured.")) jc_ipv4_netmask = 24 if jc.jc_ipv4_network: parts = jc.jc_ipv4_network.split('/') if len(parts) > 1: jc_ipv4_netmask = parts[1] jc_ipv6_prefix = 64 if jc.jc_ipv6_network: parts = jc.jc_ipv6_network.split('/') if len(parts) > 1: jc_ipv6_prefix = parts[1] jail_host = self.cleaned_data.get('jail_host') jail_ipv4_dhcp = self.cleaned_data.get('jail_ipv4_dhcp') jail_ipv4 = self.cleaned_data.get('jail_ipv4') jail_ipv4_netmask = self.cleaned_data.get('jail_ipv4_netmask', jc_ipv4_netmask) jail_ipv6_autoconf = self.cleaned_data.get('jail_ipv6_autoconf') jail_ipv6 = self.cleaned_data.get('jail_ipv6') jail_ipv6_prefix = self.cleaned_data.get('jail_ipv6_prefix', jc_ipv6_prefix) jail_flags = WARDEN_FLAGS_NONE jail_flags |= WARDEN_CREATE_FLAGS_VANILLA jail_create_args = {} jail_create_args['jail'] = jail_host w = Warden() template_create_args = {} jail_type = self.cleaned_data['jail_type'] if not jail_type: jail_type = 'standard' template = JailTemplate.objects.get(jt_name=jail_type) template_create_args['nick'] = template.jt_name template_create_args['tar'] = template.jt_url template_create_args['flags'] = WARDEN_TEMPLATE_FLAGS_CREATE | \ WARDEN_TEMPLATE_CREATE_FLAGS_NICK | \ WARDEN_TEMPLATE_CREATE_FLAGS_TAR if template.jt_mtree: template_create_args['mtree'] = template.jt_mtree template_create_args['flags'] = template_create_args['flags'] | \ WARDEN_TEMPLATE_CREATE_FLAGS_MTREE saved_template = template template = None template_list_flags = {} template_list_flags['flags'] = WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break createfile = "/var/tmp/.templatecreate" if not template: try: cf = open(createfile, "a+") cf.close() w.template(**template_create_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) if os.path.exists(createfile): os.unlink(createfile) return template_list_flags = {} template_list_flags['flags'] = WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break if not template: self.errors['__all__'] = self.error_class( [_('Unable to find template!')]) return if template['type'] == 'Linux': jail_flags |= WARDEN_CREATE_FLAGS_LINUXJAIL if template['arch'] == 'i386' and self.arch == 'x64': jail_flags |= WARDEN_CREATE_FLAGS_32BIT jail_flags |= WARDEN_CREATE_FLAGS_TEMPLATE jail_create_args['template'] = template_create_args['nick'] if jail_ipv4_dhcp: jail_ipv4 = "DHCP" if jail_ipv4: if jail_ipv4 != "DHCP": jail_ipv4 = "%s/%s" % (jail_ipv4, jail_ipv4_netmask) jail_flags |= WARDEN_CREATE_FLAGS_IPV4 jail_create_args['ipv4'] = jail_ipv4 if jail_ipv6_autoconf: jail_ipv6 = "AUTOCONF" if jail_ipv6: if jail_ipv6 != "AUTOCONF": jail_ipv6 = "%s/%s" % (jail_ipv6, jail_ipv6_prefix) jail_flags |= WARDEN_CREATE_FLAGS_IPV6 jail_create_args['ipv6'] = jail_ipv6 jail_flags |= WARDEN_CREATE_FLAGS_LOGFILE jail_flags |= WARDEN_CREATE_FLAGS_SYSLOG jail_create_args['logfile'] = self.logfile jail_create_args['flags'] = jail_flags createfile = "/var/tmp/.jailcreate" try: cf = open(createfile, "a+") cf.close() w.create(**jail_create_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) if os.path.exists(createfile): os.unlink(createfile) return if os.path.exists(createfile): os.unlink(createfile) for key in ('jail_bridge_ipv4', 'jail_bridge_ipv6', 'jail_defaultrouter_ipv4', 'jail_defaultrouter_ipv6', 'jail_mac', 'jail_iface', 'jail_flags'): jail_set_args = {} jail_set_args['jail'] = jail_host jail_flags = WARDEN_FLAGS_NONE val = self.cleaned_data.get(key, None) if val: if key == 'jail_bridge_ipv4': mask = self.cleaned_data.get('jail_bridge_ipv4_netmask', jc_ipv4_netmask) jail_flags |= WARDEN_SET_FLAGS_BRIDGE_IPV4 jail_set_args['bridge-ipv4'] = "%s/%s" % (val, mask) elif key == 'jail_bridge_ipv6': prefix = self.cleaned_data.get('jail_bridge_ipv6_prefix', jc_ipv6_prefix) jail_flags |= WARDEN_SET_FLAGS_BRIDGE_IPV6 jail_set_args['bridge-ipv6'] = "%s/%s" % (val, prefix) elif key == 'jail_defaultrouter_ipv4': jail_flags |= WARDEN_SET_FLAGS_DEFAULTROUTER_IPV4 jail_set_args['defaultrouter-ipv4'] = val elif key == 'jail_defaultrouter_ipv6': jail_flags |= WARDEN_SET_FLAGS_DEFAULTROUTER_IPV6 jail_set_args['defaultrouter-ipv6'] = val elif key == 'jail_mac': jail_flags |= WARDEN_SET_FLAGS_MAC jail_set_args['mac'] = val elif key == 'jail_iface': jail_flags |= WARDEN_SET_FLAGS_IFACE jail_set_args['iface'] = val elif key == 'jail_flags': jail_flags |= WARDEN_SET_FLAGS_FLAGS jail_set_args['jflags'] = val elif key == 'jail_mac': jail_mac_list = [jail.jail_mac for jail in Jails.objects.all()] mac_address = generate_randomMAC() while mac_address in jail_mac_list: mac_address = generate_randomMAC() jail_flags |= WARDEN_SET_FLAGS_MAC jail_set_args['mac'] = mac_address jail_set_args['flags'] = jail_flags try: w.set(**jail_set_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return jail_nat = self.cleaned_data.get('jail_nat', None) jail_vnet = self.cleaned_data.get('jail_vnet', None) if jc.jc_ipv4_dhcp or jc.jc_ipv6_autoconf: jail_vnet = True jail_set_args = {} jail_set_args['jail'] = jail_host jail_flags = WARDEN_FLAGS_NONE if jail_nat: jail_flags |= WARDEN_SET_FLAGS_NAT_ENABLE else: jail_flags |= WARDEN_SET_FLAGS_NAT_DISABLE jail_set_args['flags'] = jail_flags try: w.set(**jail_set_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return jail_set_args = {} jail_set_args['jail'] = jail_host jail_flags = WARDEN_FLAGS_NONE if jail_vnet: # XXXX if NOT LINUX XXXX (revisit this) if (saved_template.jt_arch != 'x86' and saved_template.jt_os != 'Linux'): jail_flags |= WARDEN_SET_FLAGS_VNET_ENABLE else: jail_flags |= WARDEN_SET_FLAGS_VNET_DISABLE jail_set_args['flags'] = jail_flags try: w.set(**jail_set_args) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return if self.cleaned_data['jail_autostart']: try: w.auto(jail=jail_host) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return try: w.start(jail=jail_host) except Exception as e: self.errors['__all__'] = self.error_class([_(e.message)]) return # Requery instance so we have everything up-to-date after save # See #14686 self.instance = Jails.objects.get(jail_host=jail_host) if self.instance: add_media_user_and_group(self.instance.jail_path)
def perftest(request): systemdataset, volume, basename = notifier().system_dataset_settings() if request.method == 'GET': p1 = subprocess.Popen([ '/usr/local/bin/perftests-nas', '-t', ], stdout=subprocess.PIPE, stderr=subprocess.PIPE) tests = p1.communicate()[0].strip('\n').split('\n') return render(request, 'system/perftest.html', { 'tests': tests, }) if not basename: raise MiddlewareError( _('System dataset is required to perform this action.')) dump = os.path.join(notifier().system_dataset_path(), 'perftest.txz') perftestdataset = '%s/perftest' % basename perftestdir = os.path.join(notifier().system_dataset_path(), 'perftest') with mntlock(mntpt=notifier().system_dataset_path()): _n = notifier() rv, errmsg = _n.create_zfs_dataset( path=perftestdataset, props={ 'primarycache': 'metadata', 'secondarycache': 'metadata', 'mountpoint': 'legacy', 'compression': 'off', }, _restart_collectd=False, ) currdir = os.getcwd() if not os.path.isdir(perftestdir): os.mkdir(perftestdir) os.chdir(perftestdir) os.system('/sbin/mount -t zfs %s %s' % (perftestdataset, perftestdir)) p1 = subprocess.Popen([ '/usr/local/bin/perftests-nas', '-o', perftestdataset.encode('utf8'), '-s', str(PERFTEST_SIZE), ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) p1.communicate() os.chdir('..') p1 = pipeopen('tar -cJf %s perftest' % dump) p1.communicate() os.chdir(currdir) os.system('/sbin/umount -f %s' % perftestdataset) os.rmdir(perftestdir) _n.destroy_zfs_dataset(perftestdataset) return JsonResp( request, message='Performance test has completed.', events=[ 'window.location=\'%s\'' % reverse('system_perftest_download'), ], )
self.fields['destination'].widget.attrs['root'] = jail_path self.fields['mpjc_path'].widget = forms.widgets.HiddenInput() self.fields['mpjc_path'].initial = self.jc.jc_path if self.instance.id: self.fields['mounted'].initial = self.instance.mounted else: self.fields['mounted'].widget = forms.widgets.HiddenInput() def save(self, *args, **kwargs): obj = super(NullMountPointForm, self).save(*args, **kwargs) mounted = self.cleaned_data.get("mounted") if mounted == obj.mounted: return obj if mounted: try: obj.mount() except ValueError, e: raise MiddlewareError( _("The path could not be mounted %s: %s") % ( obj.source, e, )) elif obj.umount(): #FIXME better error handling, show the user why raise MiddlewareError( _("The path could not be umounted %s") % (obj.source, )) return obj
p = os.popen(". /etc/rc.freenas; jail_update_fstab '%s';" % self.cleaned_data.get('jail')) p.close() mounted = self.cleaned_data.get("mounted") if mounted == obj.mounted: return obj if mounted: try: obj.mount() except ValueError, e: raise MiddlewareError( _("The path could not be mounted %(source)s: %(error)s") % { 'source': obj.source, 'error': e, }) else: try: obj.umount() except ValueError, e: raise MiddlewareError( _("The path could not be umounted %(source)s: %(error)s" % { 'source': obj.source, 'error': e, })) return obj
def save(self): try: super(ActiveDirectoryForm, self).save() except Exception as e: raise MiddlewareError(e)
def jail_auto_configure(): import platform """ Auto configure the jail settings The first ZFS volume found will be selected. A dataset called jails will be created, if it already exists then append "_N" where N 2..100 until a dataset is not found. """ vol_fstype = 'ZFS' volume = Volume.objects.filter(vol_fstype='ZFS') if not volume.exists(): log.warn("ZFS is recommended for plugins!") volume = Volume.objects.filter(vol_fstype='UFS') if not volume.exists(): raise MiddlewareError(_("You need to create a volume to proceed!")) vol_fstype = 'UFS' volume = volume[0] basename = "%s/jails" % volume.vol_name if vol_fstype == 'ZFS': name = basename for i in xrange(2, 100): datasets = list_datasets( path="/mnt/%s" % name, recursive=False, ) if not datasets: break else: name = "%s_%d" % (basename, i) rv, err = notifier().create_zfs_dataset(name) if rv != 0: raise MiddlewareError( _("Failed to create dataset %(name)s: %(error)s") % { 'name': name, 'error': err, }) elif vol_fstype == 'UFS': name = "/mnt/%s" % basename if os.path.exists(name): max = 1 dirs = glob.glob("%s_*" % name) if dirs: for d in dirs: parts = d.split('_') if len(parts) > 1 and re.match('^[0-9]+$', parts[1]): num = int(parts[1]) if num > max: max = num name = "%s_%d" % (name, max + 1) name = name.replace('/mnt/', '') try: os.makedirs("/mnt/%s" % name) except Exception as e: raise MiddlewareError( _("Failed to create directory %(name)s: %(error)s") % { 'name': name, 'error': e }) try: jail = JailsConfiguration.objects.latest('id') except JailsConfiguration.DoesNotExist: jail = JailsConfiguration() jail.jc_path = "/mnt/%s" % name jail.save() w = warden.Warden() w.wtmp = jail.jc_path w.jdir = jail.jc_path w.release = platform.release().strip() w.save()
def install_available(request, oid): try: jc = JailsConfiguration.objects.all()[0] except IndexError: jc = JailsConfiguration.objects.create() try: if not jail_path_configured(): jail_auto_configure() if not jc.jc_ipv4_dhcp: addrs = guess_addresses() if not addrs['high_ipv4']: raise MiddlewareError(_("No available IP addresses")) except MiddlewareError as e: return render(request, "plugins/install_error.html", { 'error': e.value, }) if os.path.exists("/tmp/.plugin_upload_update"): os.unlink("/tmp/.plugin_upload_update") if os.path.exists(PROGRESS_FILE): os.unlink(PROGRESS_FILE) plugin = None for p in availablePlugins.get_remote(cache=True): if p.id == oid: plugin = p break if not plugin: raise MiddlewareError(_("Invalid plugin")) if request.method == "POST": plugin_upload_path = notifier().get_plugin_upload_path() notifier().change_upload_location(plugin_upload_path) if not plugin.download("/var/tmp/firmware/pbifile.pbi"): raise MiddlewareError(_("Failed to download plugin")) try: jail = new_default_plugin_jail(plugin.unixname) except IOError as e: raise MiddlewareError(str(e)) except MiddlewareError as e: raise e except Exception as e: raise MiddlewareError(str(e)) newplugin = [] if notifier().install_pbi(jail.jail_host, newplugin): newplugin = newplugin[0] notifier()._restart_plugins( jail=newplugin.plugin_jail, plugin=newplugin.plugin_name, ) else: jail.delete() return JsonResp( request, message=_("Plugin successfully installed"), events=['reloadHttpd()'], ) return render(request, "plugins/available_install.html", { 'plugin': plugin, })
def save(self): enable = self.cleaned_data.get("ad_enable") enable_monitoring = self.cleaned_data.get("ad_enable_monitor") monit_frequency = self.cleaned_data.get("ad_monitor_frequency") monit_retry = self.cleaned_data.get("ad_recover_retry") fqdn = self.cleaned_data.get("ad_domainname") sm = None if self.__original_changed(): notifier().clear_activedirectory_config() started = notifier().started( "activedirectory", timeout=_fs().directoryservice.activedirectory.timeout.started) obj = super(ActiveDirectoryForm, self).save() try: utils.get_idmap_object(obj.ds_type, obj.id, obj.ad_idmap_backend) except ObjectDoesNotExist: log.debug( 'IDMAP backend {} entry does not exist, creating one.'.format( obj.ad_idmap_backend)) utils.get_idmap(obj.ds_type, obj.id, obj.ad_idmap_backend) self.cifs.cifs_srv_netbiosname = self.cleaned_data.get( "ad_netbiosname_a") self.cifs.cifs_srv_netbiosname_b = self.cleaned_data.get( "ad_netbiosname_b") self.cifs.cifs_srv_netbiosalias = self.cleaned_data.get( "ad_netbiosalias") self.cifs.save() if enable: if started is True: timeout = _fs( ).directoryservice.activedirectory.timeout.restart try: started = notifier().restart("activedirectory", timeout=timeout) except Exception as e: raise MiddlewareError( _("Active Directory restart timed out after %d seconds." % timeout), ) if started is False: timeout = _fs().directoryservice.activedirectory.timeout.start try: started = notifier().start("activedirectory", timeout=timeout) except Exception as e: raise MiddlewareError( _("Active Directory start timed out after %d seconds." % timeout), ) if started is False: self.instance.ad_enable = False super(ActiveDirectoryForm, self).save() raise MiddlewareError( _("Active Directory failed to reload."), ) else: if started is True: timeout = _fs().directoryservice.activedirectory.timeout.stop try: started = notifier().stop("activedirectory", timeout=timeout) except Exception as e: raise MiddlewareError( _("Active Directory stop timed out after %d seconds." % timeout), ) sm_name = 'activedirectory' try: sm = ServiceMonitor.objects.get(sm_name=sm_name) except Exception as e: log.debug("XXX: Unable to find ServiceMonitor: %s", e) pass # # Ports can be specified in the UI but there doesn't appear to be a way to # override them via SRV records. This should be fixed. # dcport = self.get_dcport() # gcport = self.get_gcport() if not sm: try: log.debug( "XXX: fqdn=%s dcport=%s frequency=%s retry=%s enable=%s", fqdn, dcport, monit_frequency, monit_retry, enable_monitoring) sm = ServiceMonitor.objects.create( sm_name=sm_name, sm_host=fqdn, sm_port=dcport, sm_frequency=monit_frequency, sm_retry=monit_retry, sm_enable=enable_monitoring) except Exception as e: log.debug("XXX: Unable to create ServiceMonitor: %s", e) raise MiddlewareError( _("Unable to create ServiceMonitor: %s" % e), ) else: sm.sm_name = sm_name if fqdn != sm.sm_host: sm.sm_host = fqdn if dcport != sm.sm_port: sm.sm_port = dcport if monit_frequency != sm.sm_frequency: sm.sm_frequency = monit_frequency if monit_retry != sm.sm_retry: sm.sm_retry = monit_retry if enable_monitoring != sm.sm_enable: sm.sm_enable = enable_monitoring try: sm.save(force_update=True) except Exception as e: log.debug("XXX: Unable to create ServiceMonitor: %s", e) raise MiddlewareError( _("Unable to save ServiceMonitor: %s" % e), ) with client as c: if enable_monitoring and enable: log.debug( "[ServiceMonitoring] Add %s service, frequency: %d, retry: %d" % ('activedirectory', monit_frequency, monit_retry)) c.call('servicemonitor.restart') else: log.debug( "[ServiceMonitoring] Remove %s service, frequency: %d, retry: %d" % ('activedirectory', monit_frequency, monit_retry)) c.call('servicemonitor.restart') return obj
def plugin_update(request, oid): host = get_base_url(request) jc = JailsConfiguration.objects.order_by("-id")[0] logfile = '%s/warden.log' % jc.jc_path if os.path.exists(logfile): os.unlink(logfile) if os.path.exists(WARDEN_EXTRACT_STATUS_FILE): os.unlink(WARDEN_EXTRACT_STATUS_FILE) if os.path.exists("/tmp/.plugin_upload_install"): os.unlink("/tmp/.plugin_upload_install") if os.path.exists("/tmp/.jailcreate"): os.unlink("/tmp/.jailcreate") if os.path.exists(PROGRESS_FILE): os.unlink(PROGRESS_FILE) iplugin = models.Plugins.objects.filter(id=oid) if not iplugin: raise MiddlewareError(_("Plugin not installed")) iplugin = iplugin[0] rplugin = None for rp in availablePlugins.get_remote(cache=True): if rp.name.lower() == iplugin.plugin_name.lower(): rplugin = rp break if not rplugin: raise MiddlewareError(_("Invalid plugin")) (p, js, jail_status) = get_plugin_status([iplugin, host, request]) if js and js['status'] == 'RUNNING': (p, js, jail_status) = get_plugin_stop([iplugin, host, request]) if request.method == "POST": plugin_upload_path = notifier().get_plugin_upload_path() notifier().change_upload_location(plugin_upload_path) if not rplugin.download("/var/tmp/firmware/pbifile.pbi"): raise MiddlewareError(_("Failed to download plugin")) jail = Jails.objects.filter(jail_host=iplugin.plugin_jail) if not jail: raise MiddlewareError(_("Jail does not exist")) if notifier().update_pbi(plugin=iplugin): notifier()._start_plugins( jail=iplugin.plugin_jail, plugin=iplugin.plugin_name, ) else: raise MiddlewareError(_("Failed to update plugin")) return JsonResp( request, message=_("Plugin successfully updated"), events=['reloadHttpd()'], ) return render(request, "plugins/plugin_update.html", { 'plugin': rplugin, })
def zfs_online_disk(self, volume, label): try: with client as c: c.call('pool.online', volume.id, {'label': label}) except Exception as e: raise MiddlewareError(f'Disk online failed: {str(e)}')
def geli_delkey(self, volume): try: with client as c: c.call('pool.recoverykey_rm', volume.id) except Exception as e: raise MiddlewareError(f'Failed to remove recovery key: {str(e)}')
def save(self): try: super(LDAPForm, self).save() except Exception as e: raise MiddlewareError(e)
def __init__(self, *args, **kwargs): super(JailsEditForm, self).__init__(*args, **kwargs) self.__myfields = [ 'jail_autostart', 'jail_ipv4', 'jail_ipv4_netmask', 'jail_alias_ipv4', 'jail_bridge_ipv4', 'jail_bridge_ipv4_netmask', 'jail_alias_bridge_ipv4', 'jail_defaultrouter_ipv4', 'jail_ipv6', 'jail_ipv6_prefix', 'jail_alias_ipv6', 'jail_bridge_ipv6', 'jail_bridge_ipv6_prefix', 'jail_alias_bridge_ipv6', 'jail_defaultrouter_ipv6', 'jail_mac', 'jail_iface', 'jail_vnet', 'jail_nat', 'jail_flags', ] try: self.jc = JailsConfiguration.objects.order_by("-id")[0] except Exception as e: raise MiddlewareError(e.message) jail_ipv4_dhcp = False jail_ipv6_autoconf = False if self.jc.jc_ipv4_dhcp: jail_ipv4_dhcp = True if self.jc.jc_ipv6_autoconf: jail_ipv6_autoconf = True if self.instance: if (self.instance.jail_ipv4 and self.instance.jail_ipv4.startswith("DHCP")): jail_ipv4_dhcp = True if (self.instance.jail_ipv6 and self.instance.jail_ipv6.startswith("AUTOCONF")): jail_ipv6_autoconf = True self.fields['jail_ipv4_dhcp'].initial = jail_ipv4_dhcp self.fields['jail_ipv6_autoconf'].initial = jail_ipv6_autoconf if self._api and self.instance and self.instance.id: self.instance = Jails.objects.get(id=self.instance.id) instance = getattr(self, 'instance', None) self.__instance_save(instance, self.__myfields) self.fields['jail_vnet'].widget.attrs['onChange'] = ( "jail_vnet_toggle();") self.fields['jail_nat'].widget.attrs['onChange'] = ( "jail_nat_toggle();") self.fields['jail_ipv4_dhcp'].widget.attrs['onChange'] = ( "jail_ipv4_dhcp_toggle();") self.fields['jail_ipv6_autoconf'].widget.attrs['onChange'] = ( "jail_ipv6_autoconf_toggle();") self.__set_ro(instance, 'jail_host') self.__set_ro(instance, 'jail_type')
'error': e.value, }) if os.path.exists("/tmp/.plugin_upload_update"): os.unlink("/tmp/.plugin_upload_update") if os.path.exists(PROGRESS_FILE): os.unlink(PROGRESS_FILE) plugin = None for p in availablePlugins.get_remote(cache=True): if p.id == oid: plugin = p break if not plugin: raise MiddlewareError(_("Invalid plugin")) if request.method == "POST": plugin_upload_path = notifier().get_plugin_upload_path() notifier().change_upload_location(plugin_upload_path) if not plugin.download("/var/tmp/firmware/pbifile.pbi"): raise MiddlewareError(_("Failed to download plugin")) try: jail = new_default_plugin_jail(plugin.unixname) except IOError, e: raise MiddlewareError(unicode(e)) except MiddlewareError, e: raise e
def save(self): jail_host = self.cleaned_data.get('jail_host') instance = getattr(self, 'instance', None) if self.__instance_diff(instance, self.__myfields): self.__instance_changed_fields(instance, self.__myfields) changed_fields = self.__instance_changed_fields( instance, self.__myfields) try: jc = JailsConfiguration.objects.order_by("-id")[0] except Exception as e: raise MiddlewareError(e.message) if not jc.jc_path: raise MiddlewareError(_("No jail root configured.")) jc_ipv4_netmask = 24 if jc.jc_ipv4_network: parts = jc.jc_ipv4_network.split('/') if len(parts) > 1: jc_ipv4_netmask = parts[1] jc_ipv6_prefix = 64 if jc.jc_ipv6_network: parts = jc.jc_ipv6_network.split('/') if len(parts) > 1: jc_ipv6_prefix = parts[1] jail_ipv4_dhcp = self.cleaned_data.get('jail_ipv4_dhcp', False) jail_ipv6_autoconf = self.cleaned_data.get('jail_ipv6_autoconf', False) for cf in changed_fields: if cf == 'jail_autostart': Warden().auto(jail=jail_host) else: args = {} flags = WARDEN_FLAGS_NONE if cf == 'jail_ipv4' or cf == 'jail_ipv4_netmask': ipv4 = self.cleaned_data.get('jail_ipv4') mask = self.cleaned_data.get('jail_ipv4_netmask', jc_ipv4_netmask) if jail_ipv4_dhcp: jail_ipv4 = ipv4 else: jail_ipv4 = "%s/%s" % (ipv4, mask) flags |= WARDEN_SET_FLAGS_IPV4 args['ipv4'] = jail_ipv4 elif cf == 'jail_ipv6' or cf == 'jail_ipv6_prefix': ipv6 = self.cleaned_data.get('jail_ipv6') prefix = self.cleaned_data.get('jail_ipv6_prefix', jc_ipv6_prefix) if jail_ipv6_autoconf: jail_ipv6 = ipv6 else: jail_ipv6 = "%s/%s" % (ipv6, prefix) flags |= WARDEN_SET_FLAGS_IPV6 args['ipv6'] = jail_ipv6 elif cf == 'jail_alias_ipv4': flags |= WARDEN_SET_FLAGS_ALIAS_IPV4 args['alias-ipv4'] = self.cleaned_data.get(cf) elif cf == 'jail_alias_ipv6': flags |= WARDEN_SET_FLAGS_ALIAS_IPV6 args['alias-ipv6'] = self.cleaned_data.get(cf) elif (cf == 'jail_bridge_ipv4' or cf == 'jail_bridge_ipv4_netmask'): bridge_ipv4 = self.cleaned_data.get('jail_bridge_ipv4') mask = self.cleaned_data.get('jail_bridge_ipv4_netmask', jc_ipv4_netmask) jail_bridge_ipv4 = "%s/%s" % (bridge_ipv4, mask) flags |= WARDEN_SET_FLAGS_BRIDGE_IPV4 args['bridge-ipv4'] = jail_bridge_ipv4 elif (cf == 'jail_bridge_ipv6' or cf == 'jail_bridge_ipv6_prefix'): bridge_ipv6 = self.cleaned_data.get('jail_bridge_ipv6') prefix = self.cleaned_data.get('jail_bridge_ipv6_prefix', jc_ipv6_prefix) jail_bridge_ipv6 = "%s/%s" % (bridge_ipv6, prefix) flags |= WARDEN_SET_FLAGS_BRIDGE_IPV6 args['bridge-ipv6'] = jail_bridge_ipv6 elif cf == 'jail_alias_bridge_ipv4': flags |= WARDEN_SET_FLAGS_ALIAS_BRIDGE_IPV4 args['alias-bridge-ipv4'] = self.cleaned_data.get(cf) elif cf == 'jail_alias_bridge_ipv6': flags |= WARDEN_SET_FLAGS_ALIAS_BRIDGE_IPV6 args['alias-bridge-ipv6'] = self.cleaned_data.get(cf) elif cf == 'jail_defaultrouter_ipv4': flags |= WARDEN_SET_FLAGS_DEFAULTROUTER_IPV4 args['defaultrouter-ipv4'] = self.cleaned_data.get(cf) elif cf == 'jail_defaultrouter_ipv6': flags |= WARDEN_SET_FLAGS_DEFAULTROUTER_IPV6 args['defaultrouter-ipv6'] = self.cleaned_data.get(cf) elif cf == 'jail_mac': flags |= WARDEN_SET_FLAGS_MAC args['mac'] = self.cleaned_data.get(cf) elif cf == 'jail_iface': flags |= WARDEN_SET_FLAGS_IFACE args['iface'] = self.cleaned_data.get(cf) elif cf == 'jail_vnet': if (self.cleaned_data.get(cf)): flags |= WARDEN_SET_FLAGS_VNET_ENABLE args['vnet-enable'] = self.cleaned_data.get(cf) else: flags |= WARDEN_SET_FLAGS_VNET_DISABLE args['vnet-disable'] = self.cleaned_data.get(cf) elif cf == 'jail_nat': if self.cleaned_data.get(cf): flags |= WARDEN_SET_FLAGS_NAT_ENABLE args['nat-enable'] = self.cleaned_data.get(cf) else: flags |= WARDEN_SET_FLAGS_NAT_DISABLE args['nat-disable'] = self.cleaned_data.get(cf) elif cf == 'jail_flags': flags |= WARDEN_SET_FLAGS_FLAGS args['jflags'] = self.cleaned_data.get(cf) args['jail'] = jail_host args['flags'] = flags Warden().set(**args)
def new_default_plugin_jail(basename): jc = JailsConfiguration.objects.order_by("-id")[0] logfile = "%s/warden.log" % jc.jc_path if not jc.jc_ipv4_dhcp or not jc.jc_ipv6_autoconf: addrs = guess_addresses() if not jc.jc_ipv4_dhcp: if not addrs['high_ipv4']: raise MiddlewareError(_("Unable to determine IPv4 for plugin")) if (jc.jc_ipv6_autoconf or jc.jc_ipv6_network): if not jc.jc_ipv6_autoconf: if not addrs['high_ipv6']: raise MiddlewareError(_("Unable to determine IPv6 for plugin")) jailname = None for i in xrange(1, 1000): tmpname = "%s_%d" % (basename, i) jails = Jails.objects.filter(jail_host=tmpname) if not jails: jailname = tmpname break w = warden.Warden() template_create_args = {} template = JailTemplate.objects.get(jt_name='pluginjail') template_create_args['nick'] = template.jt_name template_create_args['tar'] = template.jt_url template_create_args['flags'] = warden.WARDEN_TEMPLATE_FLAGS_CREATE | \ warden.WARDEN_TEMPLATE_CREATE_FLAGS_NICK | \ warden.WARDEN_TEMPLATE_CREATE_FLAGS_TAR template = None template_list_flags = {} template_list_flags['flags'] = warden.WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break os.environ[ 'EXTRACT_TARBALL_STATUSFILE'] = warden.WARDEN_EXTRACT_STATUS_FILE createfile = "/var/tmp/.templatecreate" if not template: try: cf = open(createfile, "a+") cf.close() w.template(**template_create_args) except Exception as e: if os.path.exists(createfile): os.unlink(createfile) raise MiddlewareError(e.message) template_list_flags = {} template_list_flags['flags'] = warden.WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break if not template: raise MiddlewareError(_('Unable to find template!')) try: high_ipv4 = "DHCP" if not jc.jc_ipv4_dhcp: high_ipv4 = addrs['high_ipv4'] high_ipv6 = "AUTOCONF" if not jc.jc_ipv6_autoconf: high_ipv6 = addrs['high_ipv6'] create_args = { 'jail': jailname, 'ipv4': high_ipv4, 'ipv6': high_ipv6, 'flags': (warden.WARDEN_CREATE_FLAGS_LOGFILE | warden.WARDEN_CREATE_FLAGS_TEMPLATE | warden.WARDEN_CREATE_FLAGS_VANILLA | warden.WARDEN_CREATE_FLAGS_SYSLOG | warden.WARDEN_CREATE_FLAGS_IPV4 | warden.WARDEN_CREATE_FLAGS_IPV6), 'template': 'pluginjail', 'logfile': logfile } w.create(**create_args) except Exception, e: raise MiddlewareError(_("Failed to install plugin: %s") % e)
def upload(request, jail_id=-1): try: jc = JailsConfiguration.objects.all()[0] except: jc = None # FIXME: duplicated code with available_install try: if not jail_path_configured(): jail_auto_configure() if not jc: jc = JailsConfiguration.objects.all()[0] if not jc.jc_ipv4_dhcp: addrs = guess_addresses() if not addrs['high_ipv4']: raise MiddlewareError(_("No available IP addresses")) except MiddlewareError as e: return render(request, "plugins/install_error.html", { 'error': e.value, }) plugin_upload_path = notifier().get_plugin_upload_path() notifier().change_upload_location(plugin_upload_path) jail = None if jail_id > 0: try: jail = Jails.objects.filter(pk=jail_id)[0] except Exception as e: log.debug("Failed to get jail %d: %s", jail_id, repr(e)) jail = None if request.method == "POST": jc = JailsConfiguration.objects.order_by("-id")[0] logfile = '%s/warden.log' % jc.jc_path if os.path.exists(logfile): os.unlink(logfile) if os.path.exists(WARDEN_EXTRACT_STATUS_FILE): os.unlink(WARDEN_EXTRACT_STATUS_FILE) if os.path.exists("/tmp/.plugin_upload_install"): os.unlink("/tmp/.plugin_upload_install") if os.path.exists("/tmp/.jailcreate"): os.unlink("/tmp/.jailcreate") form = forms.PBIUploadForm(request.POST, request.FILES, jail=jail) if form.is_valid(): form.done() return JsonResp( request, message=_('Plugin successfully installed'), events=['reloadHttpd()'], ) else: resp = render(request, "plugins/upload.html", { 'form': form, }) resp.content = ("<html><body><textarea>" + resp.content + "</textarea></boby></html>") return resp else: form = forms.PBIUploadForm(jail=jail) return render(request, "plugins/upload.html", { 'form': form, })
def update_check(request): try: updateobj = models.Update.objects.order_by('-id')[0] except IndexError: updateobj = models.Update.objects.create() if request.method == 'POST': uuid = request.GET.get('uuid') if request.POST.get('apply') == '1': apply_ = True else: apply_ = False handler = UpdateHandler(uuid=uuid, apply_=apply_) if not uuid: #FIXME: ugly pid = os.fork() if pid != 0: return HttpResponse(handler.uuid, status=202) else: handler.pid = os.getpid() handler.dump() path = notifier().system_dataset_path() if not path: raise MiddlewareError(_('System dataset not configured')) try: if handler.apply: Update( train=updateobj.get_train(), get_handler=handler.get_handler, install_handler=handler.install_handler, cache_dir='%s/update' % path, ) else: DownloadUpdate( updateobj.get_train(), '%s/update' % path, check_handler=handler.get_handler, get_handler=handler.get_file_handler, ) except Exception, e: from freenasUI.common.log import log_traceback log_traceback(log=log) handler.error = unicode(e) handler.finished = True handler.dump() os.kill(handler.pid, 9) else: if handler.error is not False: raise MiddlewareError(handler.error) if not handler.finished: return HttpResponse(handler.uuid, status=202) handler.exit() if handler.apply: request.session['allow_reboot'] = True return render(request, 'system/done.html') else: return JsonResp( request, message=_('Packages downloaded'), )
def __init__(self, *args, **kwargs): super(JailCreateForm, self).__init__(*args, **kwargs) if not jail_path_configured(): jail_auto_configure() try: self.jc = JailsConfiguration.objects.order_by("-id")[0] except Exception as e: raise MiddlewareError(e) self.logfile = "/var/tmp/warden.log" self.statusfile = "/var/tmp/status" try: os.unlink(self.logfile) except: pass try: os.unlink(self.statusfile) except: pass arch = platform.architecture() if arch[0] == '64bit': arch = 'x64' else: arch = 'x86' self.arch = arch os.environ['EXTRACT_TARBALL_STATUSFILE'] = self.statusfile self.fields['jail_type'].choices = choices.JAIL_TEMPLATE_CHOICES() self.fields['jail_type'].widget.attrs['onChange'] = ( "jail_type_toggle();") self.fields['jail_vnet'].widget.attrs['onChange'] = ( "jail_vnet_toggle();") self.fields['jail_nat'].widget.attrs['onChange'] = ( "jail_nat_toggle();") self.fields['jail_ipv4_dhcp'].widget.attrs['onChange'] = ( "jail_ipv4_dhcp_toggle();") self.fields['jail_ipv6_autoconf'].widget.attrs['onChange'] = ( "jail_ipv6_autoconf_toggle();") if not self.jc.jc_ipv4_dhcp: ipv4_addrs = guess_ipv4_addresses() if ipv4_addrs['high_ipv4']: parts = str(ipv4_addrs['high_ipv4']).split('/') self.fields['jail_ipv4'].initial = parts[0] if len(parts) > 1: self.fields['jail_ipv4_netmask'].initial = parts[1] if ipv4_addrs['bridge_ipv4']: parts = str(ipv4_addrs['bridge_ipv4']).split('/') self.fields['jail_bridge_ipv4'].initial = parts[0] if len(parts) > 1: self.fields['jail_bridge_ipv4_netmask'].initial = parts[1] else: self.fields['jail_ipv4_dhcp'].initial = True if not self.jc.jc_ipv6_autoconf: ipv6_addrs = guess_ipv6_addresses() if ipv6_addrs['high_ipv6']: parts = str(ipv6_addrs['high_ipv6']).split('/') self.fields['jail_ipv6'].initial = parts[0] if len(parts) > 1: self.fields['jail_ipv6_prefix'].initial = parts[1] if ipv6_addrs['bridge_ipv6']: parts = str(ipv6_addrs['bridge_ipv6']).split('/') self.fields['jail_bridge_ipv6'].initial = parts[0] if len(parts) > 1: self.fields['jail_bridge_ipv6_prefix'].initial = parts[1] else: self.fields['jail_ipv6_autoconf'].initial = True
def new_default_plugin_jail(basename): jc = JailsConfiguration.objects.order_by("-id")[0] logfile = "%s/warden.log" % jc.jc_path if not jc.jc_ipv4_dhcp or not jc.jc_ipv6_autoconf: addrs = guess_addresses() if not jc.jc_ipv4_dhcp: if not addrs['high_ipv4']: raise MiddlewareError(_("Unable to determine IPv4 for plugin")) if (jc.jc_ipv6_autoconf or jc.jc_ipv6_network): if not jc.jc_ipv6_autoconf: if not addrs['high_ipv6']: raise MiddlewareError(_("Unable to determine IPv6 for plugin")) jailname = None for i in range(1, 1000): tmpname = "%s_%d" % (basename, i) jails = Jails.objects.filter(jail_host=tmpname) if not jails: jailname = tmpname break w = warden.Warden() template_create_args = {} template = JailTemplate.objects.get(jt_name='pluginjail') template_create_args['nick'] = template.jt_name template_create_args['tar'] = template.jt_url template_create_args['flags'] = warden.WARDEN_TEMPLATE_FLAGS_CREATE | \ warden.WARDEN_TEMPLATE_CREATE_FLAGS_NICK | \ warden.WARDEN_TEMPLATE_CREATE_FLAGS_TAR if template.jt_mtree: template_create_args['mtree'] = template.jt_mtree template_create_args['flags'] = template_create_args['flags'] | \ warden.WARDEN_TEMPLATE_CREATE_FLAGS_MTREE template = None template_list_flags = {} template_list_flags['flags'] = warden.WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break os.environ['EXTRACT_TARBALL_STATUSFILE'] = warden.WARDEN_EXTRACT_STATUS_FILE createfile = "/var/tmp/.templatecreate" if not template: # If for some reason warden does not list the template but the path # exists, we shall try to nuke it template_path = '{}/.warden-template-pluginjail'.format(jc.jc_path) if os.path.exists(template_path): try: notifier().destroy_zfs_dataset(template_path.replace('/mnt/', '')) except: pass try: shutil.rmtree(template_path) except OSError: pass try: cf = open(createfile, "a+") cf.close() w.template(**template_create_args) except Exception as e: if os.path.exists(createfile): os.unlink(createfile) raise MiddlewareError(e) template_list_flags = {} template_list_flags['flags'] = warden.WARDEN_TEMPLATE_FLAGS_LIST templates = w.template(**template_list_flags) for t in templates: if t['nick'] == template_create_args['nick']: template = t break if not template: raise MiddlewareError(_('Unable to find template!')) try: high_ipv4 = "DHCP" if not jc.jc_ipv4_dhcp: high_ipv4 = addrs['high_ipv4'] high_ipv6 = "AUTOCONF" if not jc.jc_ipv6_autoconf: high_ipv6 = addrs['high_ipv6'] create_args = { 'jail': jailname, 'ipv4': high_ipv4, 'ipv6': high_ipv6, 'flags': ( warden.WARDEN_CREATE_FLAGS_LOGFILE | warden.WARDEN_CREATE_FLAGS_TEMPLATE | warden.WARDEN_CREATE_FLAGS_VANILLA | warden.WARDEN_CREATE_FLAGS_SYSLOG | warden.WARDEN_CREATE_FLAGS_IPV4 | warden.WARDEN_CREATE_FLAGS_IPV6 ), 'template': 'pluginjail', 'logfile': logfile } w.create(**create_args) except Exception as e: raise MiddlewareError(_("Failed to install plugin: %s") % e) jaildir = "%s/%s" % (jc.jc_path, jailname) with open('%s/.plugins/PLUGIN' % jaildir, 'w') as f: f.close() w.auto(jail=jailname) w.set( jail=jailname, flags=( warden.WARDEN_SET_FLAGS_VNET_ENABLE ) ) w.start(jail=jailname) obj = Jails.objects.get(jail_host=jailname) add_media_user_and_group(obj.jail_path) return obj