rebuild client config

vpngen-cli.py

         default = variables_set[variable] if variable in variables_set else ''
         print("Enter a value for '%s' [%s]: " % (variable, default), end='', flush=True)
         value = sys.stdin.readline()[:-1]
-        if value != '':
+        if value != '' or variable not in variables_set:
             variables_set[variable] = value
     return variables_set
 
     parser.add_argument('--remove', help='Remove a VPN', action='store_true')
     parser.add_argument('--create-client', help='Create a client for the VPN', metavar='CLIENT')
     parser.add_argument('--remove-client', help='Remove a client for the VPN', metavar='CLIENT')
+    parser.add_argument('--rebuild-client', help='Rebuild a client configuration', metavar='CLIENT')
     parser.add_argument('--rebuild-clients', help='Rebuild clients configurations', action='store_true')
 
     args = parser.parse_args()
         client_name = args.create_client
     elif args.remove_client is not None:
         client_name = args.remove_client
+    elif args.rebuild_client is not None:
+        client_name = args.rebuild_client
     else:
         client_name = None
     if client_name is not None:
         config['defaults'].update(data['variables'])
 
     if args.create:
-        variables = create_variables(vpng.get_vpn_vars(), config['defaults'])
+        default_variables = config['defaults'].copy()
+        variables = create_variables(vpng.get_vpn_vars(), default_variables)
         res = vpng.create_vpn(vpn_name, variables)
         if res == vpngen.VpnGenError.Success:
             print("VPN %s created successfully" % vpn_name)
             eprint("Failed to remove VPN %s: %s" % (vpn_name, res))
             exit(1)
     elif args.create_client:
-        variables = create_variables(vpng.get_client_vars(vpn_name), config['defaults'])
+        default_variables = config['defaults'].copy()
+        default_variables.update(vpng.get_server_variables(vpn_name))
+        variables = create_variables(vpng.get_client_vars(vpn_name), default_variables)
         if variables is None:
             res = vpngen.VpnGenError.VpnDoesNotExists
         else:
         else:
             eprint("Failed to remove client %s on VPN %s: %s" % (client_name, vpn_name, res))
             exit(1)
+    elif args.rebuild_client:
+        default_variables = config['defaults'].copy()
+        default_variables.update(vpng.get_server_variables(vpn_name))
+        default_variables.update(vpng.get_client_variables(vpn_name, client_name))
+
+        res = vpng.rebuild_client(vpn_name, client_name, default_variables)
+        if res == vpngen.VpnGenError.Success:
+            print("Client %s configuration rebuilt successfully on VPN %s" % (client_name, vpn_name))
+        else:
+            eprint("Failed to rebuild client %s configuration on VPN %s: %s" % (client_name, vpn_name, res))
+            exit(1)
     elif args.rebuild_clients:
+        default_variables = config['defaults'].copy()
+        default_variables.update(vpng.get_server_variables(vpn_name))
+
         res = vpng.rebuild_clients(vpn_name)
         if res == vpngen.VpnGenError.Success:
             print("Clients configurations rebuilt successfully on VPN %s" % vpn_name)

vpngen.py

         variables = re.findall('\$\{([^}]+)}', default_config)
         variables = self.f7(variables)
 
-        return variables
+        vpn_variables = self.get_vpn_vars()
+        real_variables = []
+
+        for var in variables:
+            if var not in vpn_variables and var != "client":
+                real_variables.append(var)
+
+        return real_variables
 
     def get_base_dir(self, vpn_name):
         return "%s%s%s%s" % (self.ovpn_config_path, os.sep, vpn_name, os.sep)
 
     def get_client_default_config_path(self, vpn_name):
         base_dir = self.get_base_dir(vpn_name)
-        return "%s%sclients/client.conf" % (base_dir, os.sep)
+        return "%s%sclients%sclient.conf" % (base_dir, os.sep, os.sep)
 
     def get_client_dir(self, vpn_name, client_name):
         base_dir = self.get_base_dir(vpn_name)
         client_dir = self.get_client_dir(vpn_name, client_name)
         return "%s%s-%s.conf" % (client_dir, client_name, vpn_name)
 
+    def get_client_variables_path(self, vpn_name, client_name):
+        client_dir = self.get_client_dir(vpn_name, client_name)
+        return "%svpngen.json" % client_dir
+
     def get_client_generated_files_paths(self, vpn_name, client_name):
         keys_dir = self.get_easy_rsa_key_dir(vpn_name,)
         return [
             "%sta.key" % keys_dir
         ]
 
+    def get_client_misc_files_paths(self, vpn_name):
+        base_dir = self.get_base_dir(vpn_name)
+        return glob.glob("%smisc-files%s*" % (base_dir, os.sep))
+
     def get_all_needed_files_paths(self, vpn_name, client_name):
         return self.get_client_generated_files_paths(vpn_name, client_name) +\
-               self.get_server_needed_files_paths(vpn_name)
+               self.get_server_needed_files_paths(vpn_name) +\
+               self.get_client_misc_files_paths(vpn_name)
+
+    def get_server_variables(self, vpn_name):
+        with open(self.get_vpn_variables_path(vpn_name), "r") as f:
+            return json.load(f)['variables']
+
+    def get_client_variables(self, vpn_name, client_name):
+        with open(self.get_client_variables_path(vpn_name, client_name), "r") as f:
+            return json.load(f)['variables']
 
     def setup_vars(self, vpn_name, variables):
         easyrsadir = self.get_easy_rsa_dir(vpn_name)
 
         os.chdir(curdir)
 
-        self.build_client(vpn_name, client_name, variables)
+        os.makedirs(client_dir)
 
-        return VpnGenError.Success
+        return self.rebuild_client(vpn_name, client_name, variables)
 
     def remove_client(self, vpn_name, client_name):
         base_dir = self.get_base_dir(vpn_name)
             return VpnGenError.ClientDoesNotExists
         return VpnGenError.Success
 
-    def rebuild_clients(self, vpn_name):
-        base_dir = self.get_base_dir(vpn_name)
-        return VpnGenError.Success
-
-    def build_client(self, vpn_name, client_name, variables):
+    def rebuild_client(self, vpn_name, client_name, variables):
         client_dir = self.get_client_dir(vpn_name, client_name)
         client_conf_file = self.get_client_config_path(vpn_name, client_name)
         client_default_config_path = self.get_client_default_config_path(vpn_name)
-
         with open(client_default_config_path, "r") as f:
             client_default_config = f.read()
 
-        variables['name'] = vpn_name
-        variables['client'] = client_name
         for variable in variables:
             client_default_config = client_default_config.replace("${%s}" % variable, variables[variable])
 
-        os.makedirs(client_dir)
+        files_names = glob.glob("%s%s*" % (client_dir, os.sep))
+        for file_name in files_names:
+            os.remove(file_name)
+
         with open(client_conf_file, "w") as f:
             f.write(client_default_config)
 
             dest = "%s%s-%s%s" % (client_dir, os.path.basename(split[0]), vpn_name, split[1])
             shutil.copy(file_path, dest)
 
+        split = os.path.splitext(client_conf_file)
+        client_ovpn_file = "%s.ovpn" % split[0]
+        shutil.copy(client_conf_file, client_ovpn_file)
+
         files_names = glob.glob("%s%s*" % (client_dir, os.sep))
         files_names = list(map(lambda file_path: os.path.basename(file_path), files_names))
 
+
         call(["tar", "cfj", self.get_client_tarball_path(vpn_name, client_name),
               "-C", client_dir] + files_names)
+
+        client_variables = {}
+        for variable in self.get_client_vars(vpn_name):
+            client_variables[variable] = variables[variable]
+
+        with open(self.get_client_variables_path(vpn_name, client_name), "w") as f:
+            json.dump({'variables': client_variables}, f, indent=4, separators=(',', ': '))
+
+        return VpnGenError.Success