freewifi 0.1.4 → 0.1.5

data/lib/freewifi/additional/additional_functions.rb

@@ -1,8 +1,9 @@
 require 'date'
+require 'translit'
 
-class InternalFunc
+class InternalFunc_1
 
-  def datetimenow()
+  def datetimenow_1()
     d_curr = DateTime.now
     time_zone = 'Europe/Minsk'
     #   DateTime.new
@@ -11,28 +12,47 @@ class InternalFunc
     d_curr.to_s
   end
 
-  def printer_texter_wifi(text, log_level)
+  def printer_texter_wifi_1(text, log_level)
     begin
-      mess = {:datetime => datetimenow, :sdk => "freewifi", :sdk_version => Freewifi::VERSION, :message => text}
-      p mess
+      if log_level == "debug" && Freewifi_1::LOGLEVEL_1 == "debug"
+        mess = {:datetime => datetimenow_1, :sdk => "freewifi", :sdk_version => Freewifi_1::VERSION, :message => text}
+        p mess
+      end
+
     rescue
       p "Failed print message"
     end
   end
 
-  def hub_tunnelname_generator(tunnel_id, company_name)
+  def hub_tunnelname_generator_1(tunnel_id, company_name)
     comp_name = company_name
     "#{tunnel_id.to_s}_eoip_hub_auto_#{comp_name}"
   end
 
-  def company_check_wifi(compname)
+  def company_check_wifi_1(compname)
     compname2=""
     if compname.include?(" ")
-      compname2 = compname.gsub(" ","")
+      compname2 = compname.gsub(" ", "")
     else
       compname2 = compname
     end
     compname2
   end
 
-end
+  def prep_comp_name_for_config_1(company_name)
+    res = company_name.gsub(" ", "")
+    res1 = Translit.convert(res, :english)
+    res1.slice(0..14)
+  end
+
+  def prep_ssid_for_config_1(ssid)
+    res = ssid.gsub(" ", "_")
+    res1 = Translit.convert(res, :english)
+    res1.slice(0..14)
+  end
+
+  def ap_hostname_generator(company, tunnel_id)
+    "#{self.prep_comp_name_for_config_1(company)}_#{tunnel_id.to_s}"
+  end
+
+end

data/lib/freewifi/cisco/cisco_schemes_conf_gen.rb

@@ -0,0 +1,12 @@
+class CiscoSchemesGen_1
+
+  def scheme1_fttx_config_gen_1(ap_wifi_ip, ap_wifi_gateway, ap_wifi_mask)
+    [
+        "capwap ap ip address #{ap_wifi_ip} #{ap_wifi_mask}",
+        "capwap ap ip default-gateway #{ap_wifi_gateway}",
+        "capwap ap controller ip address 172.24.211.1"
+    ]
+
+  end
+
+end

data/lib/freewifi/config.rb

@@ -0,0 +1,4 @@
+module Freewifi_1
+  LOGLEVEL_1 = "critical"
+end
+

data/lib/freewifi/database/mongo/mongoconnector.rb

@@ -5,9 +5,9 @@ require 'rubygems'
 require 'freewifi/additional/additional_functions'
 
 #class for communication with mongo database for iot API
-class MongoWifiCl
+class MongoWifiCl_1
 
-  attr_accessor :mongo_ip, :mongo_port, :client, :mongo_database, :additional_func
+  attr_accessor :mongo_ip, :mongo_port, :client, :mongo_database, :additional_func_1
 
   def initialize(mongo_ip, mongo_port, mongo_database)
     @mongo_database = mongo_database
@@ -15,13 +15,14 @@ class MongoWifiCl
     @mongo_port = mongo_port
     client_host = [mongo_ip + ":" + mongo_port]
     @client = Mongo::Client.new(client_host, :database => mongo_database)
-    @additional_func = InternalFunc.new
+
+    @additional_func_1 = InternalFunc_1.new
   end
 
-  def audit_logger_wifi(proc_name, src_ip, input_json, output_json, real_ip, subscriber_ip)
+  def audit_logger_wifi_1(proc_name, src_ip, input_json, output_json, real_ip, subscriber_ip)
     out_resp = {}
     begin
-      current = additional_func.datetimenow
+      current = additional_func_1.datetimenow_1
       collection = client[:audit]
       doc = {
           :proc_name => proc_name,
@@ -29,33 +30,35 @@ class MongoWifiCl
           :sender => {:src_ip => src_ip, :real_ip => real_ip, :subscriber_ip => subscriber_ip},
           :input_params => input_json,
           :output_params => output_json,
-          :sdk_version => Freewifi::VERSION
+          :sdk_version => Freewifi_1::VERSION
       }
       result = collection.insert_one(doc)
-      out_resp = {:code => 200, :result => "audit_logger: Request completed successfully", :body => result}
+      out_resp = {:code => 200, :result => "audit_logger_wifi_1: Request completed successfully", :body => result, :sdk => "freewifi"}
     rescue
-      out_resp = {:code => 507, :result => "audit_logger: Unknown SDK error"}
+      out_resp = {:code => 507, :result => "audit_logger_wifi_1: Unknown SDK error", :sdk => "freewifi"}
     end
-    additional_func.printer_texter_wifi(out_resp, "debug")
+    additional_func_1.printer_texter_wifi_1(out_resp, "debug")
     out_resp
   end
 
 
-  def data_ap_auto_created_insert(data)
+  def data_ap_auto_created_insert_1(data)
     input_params = {:data => data}
     output_params = {}
     begin
       collection = client[:ap_auto_created]
       result = collection.insert_one(data)
-      output_params = {:code => 200, :result => "data_ap_auto_created_insert: Request completed successfully", :body => result}
+      output_params = {:code => 200, :result => "data_ap_auto_created_insert_1: Request completed successfully", :body => result, :sdk => "freewifi"}
     rescue
-      output_params = {:code => 500, :result => "data_ap_auto_created_insert: failed insert data to mongo"}
+      output_params = {:code => 500, :result => "data_ap_auto_created_insert_1: failed insert data to mongo", :sdk => "freewifi"}
     end
-    additional_func.printer_texter_wifi({:input_params => input_params, :output_params => output_params, :procedure => "data_ap_auto_created_insert", :file => "freewifi/database/mongo/mongoconnector.rb"}, "debug")
+    additional_func_1.printer_texter_wifi_1({:input_params => input_params, :output_params => output_params, :procedure => "data_ap_auto_created_insert_1", :file => "freewifi/database/mongo/mongoconnector.rb", :sdk => "freewifi"}, "debug")
     output_params
   end
 
-  def get_ap_info_sim_ip_wifi(sim_ipaddress, sim_msisdn)
+  def get_ap_info_sim_ip_wifi_1(sim_ipaddress, sim_msisdn)
+    input_params = {:sim_ipaddress => sim_ipaddress, :sim_msisdn => sim_msisdn}
+    output_params = {}
     begin
       result_ps = []
       collection = client[:ap_auto_created]
@@ -63,13 +66,15 @@ class MongoWifiCl
         result_ps << row
         #result_ps.append(row)
       }
-      result_ps[0]
+      output_params = {:code => 200, :result => "get_ap_info_sim_ip_wifi_1: Request completed successfully", :body => {:all_mongo => result_ps, :tunnel_id => result_ps[0]["tunnel_id"] }, :sdk => "freewifi"}
     rescue
-      []
+      output_params = {:code => 500, :result => "get_ap_info_sim_ip_wifi_1: failed ", :sdk => "freewifi"}
     end
+    additional_func_1.printer_texter_wifi_1({:input_params => input_params, :output_params => output_params, :procedure => "get_ap_info_sim_ip_wifi_1", :file => "freewifi/database/mongo/mongoconnector.rb", :sdk => "freewifi"}, "debug")
+    output_params
   end
 
-  def tunnelid_remove_single_mongo(tunnel_id)
+  def tunnelid_remove_single_mongo_1(tunnel_id)
     out_resp = {}
     begin
       collection = client[:ap_auto_created]
@@ -78,9 +83,9 @@ class MongoWifiCl
       }
       result = collection.delete_many(doc)
       p result
-      out_resp = {:code => 200, :result => "tunnelid_remove_single_mongo: Request completed successfully"}
+      out_resp = {:code => 200, :result => "tunnelid_remove_single_mongo_1: Request completed successfully", :sdk => "freewifi"}
     rescue
-      out_resp = {:code => 507, :result => "tunnelid_remove_single_mongo: Unknown SDK error"}
+      out_resp = {:code => 507, :result => "tunnelid_remove_single_mongo_1: Unknown SDK error", :sdk => "freewifi"}
     end
     #internal_func.printer_texter(out_resp, "debug")
     out_resp

data/lib/freewifi/database/mysql/database_methods_wifi.rb

@@ -2,7 +2,7 @@
 
 require 'mysql2'
 
-class DatabaseMethodsWifi
+class DatabaseMethodsWifi_1
 
   attr_accessor :database_username, :database_password, :database_host
 

data/lib/freewifi/mikrotik/newhub_mtik_ssh.rb

@@ -0,0 +1,321 @@
+require 'net/ssh'
+require 'ipaddr'
+require 'json'
+require 'ipaddr'
+require 'date'
+require "freewifi/additional/additional_functions"
+
+
+class NEWhubWifi_1
+
+  attr_accessor :t_id_min, :t_id_max, :additional_func_wifi_1
+
+  def initialize
+    @t_id_min = 10001
+    @t_id_max = 65535
+
+    @additional_func_wifi_1 = InternalFunc_1.new
+  end
+
+
+  def del_eoip_for_mikr_1(tunnel_id, hub1, hub2, user_hub, password_hub)
+
+    begin
+      Net::SSH.start(hub1, user_hub, :password => password_hub) do |ssh|
+        #result = ssh.exec!("/interface eoip print where tunnel-id=#{tunnel_id}")
+        #p result
+        result = ssh.exec!("/interface eoip print where tunnel-id=#{tunnel_id}")
+        regimsi = /\s+name=\"(.+)\"\s+/
+        m1 = regimsi.match(result)[1]
+        sleep 0.2
+        result2 = ssh.exec!("/interface bridge port remove [/interface bridge port find interface=#{m1}]")
+        sleep 0.2
+        result3 = ssh.exec!("/interface eoip remove [/interface eoip find where tunnel-id=#{tunnel_id}]")
+
+        #result2 = ssh.exec!("interface bridge port add bridge=#{bridge_name} interface=#{tunnel_name}")
+      end
+        #Net::SSH.stop
+    rescue
+      nil
+    end
+
+    begin
+      Net::SSH.start(hub2, user_hub, :password => password_hub) do |ssh|
+        result = ssh.exec!("/interface eoip print where tunnel-id=#{tunnel_id}")
+        regimsi = /\s+name=\"(.+)\"\s+/
+        m1 = regimsi.match(result)[1]
+        sleep 0.2
+        result2 = ssh.exec!("/interface bridge port remove [/interface bridge port find interface=#{m1}]")
+        sleep 0.2
+        result3 = ssh.exec!("/interface eoip remove [/interface eoip find where tunnel-id=#{tunnel_id}]")
+
+        #result = ssh.exec!("interface eoip add remote-address=#{ap_ip_address} tunnel-id=#{tunnel_id} name=#{tunnel_name}")
+        #result2 = ssh.exec!("interface bridge port add bridge=#{bridge_name} interface=#{tunnel_name}")
+      end
+        #Net::SSH.stop
+    rescue
+      nil
+    end
+  end
+
+
+  def ap_get_info(ap_ip_address, ap_login, ap_password)
+    res = ""
+    Net::SSH.start(ap_ip_address, ap_login, :password => ap_password) do |ssh|
+      result = ssh.exec!("system identity print")
+      dff = result.to_s
+      res = dff.gsub!("name: ", "").gsub!("\r\n\r\n", "").gsub!(" ", "")
+    end
+    res
+  end
+
+  def ap_tun_rewrite(ap_ip_address, tun_id, ap_login, ap_password)
+    res = ""
+    Net::SSH.start(ap_ip_address, ap_login, :password => ap_password) do |ssh|
+      result = ssh.exec!("/interface eoip set tunnel_to_hab1 tunnel-id=#{tun_id} remote-address=172.24.202.145")
+    end
+    res
+  end
+
+  def get_tun_id(req_num_of_tunid, busy_tun_id)
+    all_ids=[]
+    i = t_id_min
+    while i < t_id_max
+      all_ids << i
+      i=i+1
+    end
+    p all_ids
+  end
+
+  #procedure for tunnel id-s selection based on all_tunids array
+  def get_tun_id2_1(req_num_of_tunid, busy_tun_id)
+    #req_num_of_tunid - integer number of necessary tun ids
+    #busy_tun_id - [] dictionary of currently used tun ids with integer elements
+    input_params = {:req_num_of_tunid => req_num_of_tunid, :busy_tun_id => busy_tun_id}
+    output_params = {}
+    all_ids = []
+    req_tun_ids = []
+    begin
+      available_tun_id = Freewifi_1::ALL_TUNIDS - busy_tun_id
+      i = 0
+      while i < req_num_of_tunid
+        req_tun_ids << available_tun_id[i]
+        i=i+1
+      end
+      output_params = {:code => 200, :result => "get_tun_id2_1: Request completed", :body => {:selected_tun_ids => req_tun_ids}, :sdk => "freewifi"}
+    rescue
+      output_params = {:code => 500, :result => "get_tun_id2_1: Something Wrong", :sdk => "freewifi"}
+    end
+    additional_func_wifi_1.printer_texter_wifi_1({:input_params => input_params, :output_params => output_params, :procedure => "get_tun_id2_1"}, "debug")
+    output_params
+  end
+
+  #universal procedure for get currently configured eoip tunnels
+  def hub_get_all_eoip_tunnels_1(hub_ip_address, hub_login, hub_password)
+    input_params = {:hub_ip_address => hub_ip_address, :hub_login => hub_login, :hub_password => hub_password}
+    output_params = {}
+    result = ""
+    busy_tunnel_ids = []
+    begin
+      ssh_connection = Net::SSH.start(hub_ip_address, hub_login, :password => hub_password) do |ssh|
+        result = ssh.exec!("/interface eoip print where tunnel-id>=#{t_id_min.to_s} tunnel-id<=#{t_id_max.to_s}")
+      end
+      #p ssh_connection.
+      reg_tunnelid = /tunnel-id=(\d+)/
+      m1 = result.scan(reg_tunnelid)
+      for a1 in m1
+        if a1[0] != []
+          s1 = a1[0].to_i
+          busy_tunnel_ids << s1
+        end
+      end
+      output_params = {:code => 200, :result => "hub_get_all_eoip_tunnels_1: Request completed", :body => {:busy_tunnel_ids => busy_tunnel_ids}, :sdk => "freewifi"}
+
+    rescue
+      output_params = {:code => 500, :result => "hub_get_all_eoip_tunnels_1: Something Wrong", :sdk => "freewifi"}
+    end
+
+    additional_func_wifi_1.printer_texter_wifi_1({:input_params => input_params, :output_params => output_params, :procedure => "hub_get_all_eoip_tunnels_1"}, "debug")
+    output_params
+
+    #m1 = reg_tunnelid.scan(result)
+    #p busy_tunnel_ids
+    #g = result.split("\r\n\r\n")
+    #p g
+    #result
+  end
+
+
+  def add_eoip_for_mikr_wifi_1(bridge_name, ap_ip_address, company_name, hub1, hub2, user_hub, password_hub)
+
+    input_params = {:bridge_name => bridge_name,
+                    :ap_ip_address => ap_ip_address,
+                    :company_name => company_name,
+                    :hub1 => hub1,
+                    :hub2 => hub2,
+                    :user_hub => user_hub,
+                    :password_hub => password_hub
+    }
+    output_params = {}
+    hub1_processed = ""
+    hub2_processed = ""
+
+    get_tun_id_answ = get_tun_id2_1(1, hub_get_all_eoip_tunnels_1(hub1, user_hub, password_hub)[:body][:busy_tunnel_ids])
+    eoip_tunnel_name = additional_func_wifi_1.hub_tunnelname_generator_1(get_tun_id_answ[:body][:selected_tun_ids][0], company_name)
+
+    if get_tun_id_answ[:code] == 200
+
+      begin
+        Net::SSH.start(hub1, user_hub, :password => password_hub) do |ssh|
+          result = ssh.exec!("/interface eoip add remote-address=#{ap_ip_address} tunnel-id=#{get_tun_id_answ[:body][:selected_tun_ids][0]} name=#{eoip_tunnel_name}")
+          result2 = ssh.exec!("/interface bridge port add bridge=#{bridge_name} interface=#{eoip_tunnel_name} unknown-multicast-flood=no unknown-unicast-flood=no")
+        end
+        hub1_processed = "Success"
+      rescue
+        hub1_processed = "Failed"
+      end
+      #Net::SSH.stop
+
+      begin
+        Net::SSH.start(hub2, user_hub, :password => password_hub) do |ssh|
+          result = ssh.exec!("/interface eoip add remote-address=#{ap_ip_address} tunnel-id=#{get_tun_id_answ[:body][:selected_tun_ids][0]} name=#{eoip_tunnel_name}")
+          result2 = ssh.exec!("/interface bridge port add bridge=#{bridge_name} interface=#{eoip_tunnel_name} unknown-multicast-flood=no unknown-unicast-flood=no")
+        end
+        #Net::SSH.stop
+        hub2_processed = "Success"
+      rescue
+        hub2_processed = "Failed"
+      end
+      output_params = {:code => 200, :result => "add_eoip_for_mikr_wifi_1: Request completed", :body => {:eoip_tunnel_id => get_tun_id_answ[:body][:selected_tun_ids][0], :eoip_tunnel_name => eoip_tunnel_name, :hub1_processed => hub1_processed, :hub2_processed => hub2_processed}}
+    else
+      output_params = {:code => 500, :result => "add_eoip_for_mikr_wifi_1: Something Wrong with empty eoip tun id", :sdk => "freewifi"}
+    end
+    additional_func_wifi_1.printer_texter_wifi_1({:input_params => input_params, :output_params => output_params, :procedure => "add_eoip_for_mikr_wifi_1", :sdk => "freewifi"}, "debug")
+    output_params
+  end
+
+
+  def mikr_tunnelid_gen()
+    t_id_min = 10001
+    t_id_max = 65535
+  end
+
+  def check_pool_range_includes_1(range, ip_addr_new)
+    input_params ={:range => range, :ip_addr_new => ip_addr_new}
+    output_params = {}
+
+    begin
+      res = "nothing"
+      gs = range.split(",")
+      for j in gs
+        if j.include?("/")
+          ipaddr1 = IPAddr.new ip_addr_new
+          x1 = j.split("/")
+          ipaddr2 = ipaddr1.mask(x1[1].to_i).to_s
+          ipaddr3 = ipaddr2.to_s
+          if ipaddr3 == x1[0]
+            res = "exists"
+          end
+        else
+          if j == ip_addr_new
+            res = "exists"
+          end
+        end
+      end
+      output_params = {:code => 200, :result => "check_pool_range_includes_1: Request processed", :body => {:result => res}}
+    rescue
+      output_params = {:code => 507, :result => "check_pool_range_includes_1: Unknown SDK error"}
+    end
+
+    additional_func_wifi_1.printer_texter_wifi_1({:input_params => input_params, :output_params => output_params, :procedure => "check_pool_range_includes_1", :file => "freewifi/mikrotik/newhub_mtik_ssh.rb", :sdk => "freewifi"}, "debug")
+    output_params
+  end
+
+  def capsman_set_ip_range_1(capsman1, capsman_user1, capsman_pass1, ap_ip)
+
+  end
+
+  def capsman_new_configuration_1(wifissid, capsman1, capsman_user1, capsman_pass1, ap_ip, companyname)
+
+    conf_24ghz_name = "auto_cfg_24ghz_#{companyname}_#{wifissid}"
+    command_conf_24ghz = "/caps-man configuration add name=#{conf_24ghz_name} ssid=#{wifissid} country=belarus mode=ap hw-retries=15 channel=24_channel_24GHz_dynamic_power22 datapath=1_datapath_MTS_Local-forwarding security=security_without_passphrase_default_FREE-WiFi"
+
+    conf_5ghz_name = "auto_cfg_5ghz_#{companyname}_#{wifissid}"
+    command_conf_5ghz = "/caps-man configuration add name=#{conf_5ghz_name} ssid=#{wifissid} country=belarus mode=ap hw-retries=15 channel=5_channel_5GHz_number1_power23 datapath=1_datapath_MTS_Local-forwarding security=security_without_passphrase_default_FREE-WiFi"
+
+    command_provisioning_24ghz = "/caps-man provisioning add hw-supported-modes=b,g,gn ip-address-ranges=#{ap_ip} action=create-dynamic-enabled master-configuration=#{conf_24ghz_name} name-format=identity"
+
+    command_provisioning_5ghz = "/caps-man provisioning add hw-supported-modes=a,ac,an ip-address-ranges=#{ap_ip} action=create-dynamic-enabled master-configuration=#{conf_24ghz_name} name-format=identity"
+
+    Net::SSH.start(capsman1, capsman_user1, :password => capsman_pass1) do |ssh|
+      result = ssh.exec!(command_conf_24ghz)
+      result1 = ssh.exec!(command_conf_5ghz)
+      result2 = ssh.exec!(command_provisioning_24ghz)
+      result3 = ssh.exec!(command_provisioning_5ghz)
+    end
+
+  end
+
+  def capsman_add_ip_to_existed_1(ap_name_list, capsman1, capsman_user1, capsman_pass1, ap_ip)
+    command = "/caps-man provisioning print where "
+
+    for h in ap_name_list
+      command = command + " or master-configuration=" + h
+    end
+    command = command.gsub("where  or", "where")
+
+    final_provision_old = []
+
+    Net::SSH.start(capsman1, capsman_user1, :password => capsman_pass1) do |ssh|
+      result = ssh.exec!(command)
+      s1 = result.split("\r\n\r\n")
+      for a in s1
+        a1 = a.gsub("\r\n", "")
+        a2 = a1.gsub(",     ", ",")
+        reg_addr_range = / (\d) .+ ip-address-ranges=(\d{1,3}.+\.\d{1,3}|\d{1,3}.+\.\d{1,3}\/\d{1,2})\s+/
+        m1 = a2.scan(reg_addr_range)
+        num = m1[0][0]
+        ip_ran = m1[0][1].gsub(" ", "")
+        triplet = [num, ip_ran]
+        final_provision_old << triplet
+        exists_check = self.check_pool_range_includes_1(triplet[1], ap_ip)
+
+        if exists_check[:body][:result] != "exists"
+          #self.capsman_set_ip_range_1(capsman1, capsman_user1, capsman_pass1, ap_ip)
+          #set data to capsman
+          rewrite_ip_command = "/caps-man provisioning set numbers=#{triplet[0]} ip-address-ranges=#{triplet[1]},#{ap_ip}"
+          p rewrite_ip_command
+
+          ssh.exec!(rewrite_ip_command)
+
+        end
+      end
+    end
+
+
+  end
+
+
+  def set_capsman_config_1(wifissid, capsman1, capsman_user1, capsman_pass1, ap_ip, companyname)
+    Net::SSH.start(capsman1, capsman_user1, :password => capsman_pass1) do |ssh|
+      result = ssh.exec!("/caps-man configuration print where ssid=#{wifissid}")
+      if result == "\r\n" || result == "" || result == nil
+        self.capsman_new_configuration_1(wifissid, capsman1, capsman_user1, capsman_pass1, ap_ip, companyname)
+      else
+        p result
+        conf_names = []
+        reg_config_name = /name=\"(\S+)\"/
+        m1 = result.scan(reg_config_name)
+        for a1 in m1
+          if a1[0] != []
+            s1 = a1[0]
+            conf_names << s1
+          end
+        end
+        self.capsman_add_ip_to_existed_1(conf_names, capsman1, capsman_user1, capsman_pass1, ap_ip)
+      end
+    end
+  end
+
+
+end

data/lib/freewifi/mikrotik/schemes_conf_gen.rb

@@ -0,0 +1,54 @@
+
+
+class MtikSchemesGen_1
+
+
+  def scheme1_3g_config_gen_1(hostname, tunnel_id, hub_vip, ap_admin_password, ap_ssid, capsman)
+
+    cap_conf = "/interface wireless cap set caps-man-addresses="
+    for f in capsman
+      cap_conf = cap_conf + "," + f
+    end
+    cap_conf = cap_conf + " enabled=yes interfaces=wireless_public_interface,wlan2 bridge=bridge_tunnel"
+    cap_conf = cap_conf.gsub("caps-man-addresses=,", "caps-man-addresses=")
+
+
+    [
+        "/system identity set name=#{hostname}",
+        "/interface bridge add name=bridge_tunnel",
+        "/interface eoip add remote-address=#{hub_vip.to_s} tunnel-id=#{tunnel_id.to_s} name=tunnel_to_hub",
+        "/interface bridge port add interface=tunnel_to_hub bridge=bridge_tunnel",
+        "/interface bridge port add interface=wlan1 bridge=bridge_tunnel",
+        "/interface wireless set wlan1 mode=ap-bridge ssid=#{ap_ssid} disabled=no name=wireless_public_interface frequency=2442",
+        "/interface ppp-client set ppp-out1 apn=vpn pin=1111 disabled=no",
+        "/interface wireless set wlan2 disabled=yes",
+        "/system clock set time-zone-name=Europe/Minsk",
+        "/snmp community set numbers=0 name=\"RO2597\" addresses=172.18.25.4/32,172.17.109.3/32 security=none read-access=yes write-access=no",
+        "/snmp set enabled=yes trap-community=RO2597 trap-version=2",
+        "/system ntp client set enabled=yes primary-ntp=172.24.213.41 secondary-ntp=172.18.25.10",
+        cap_conf,
+        "/user set admin password=#{ap_admin_password}",
+    ]
+
+  end
+
+
+  def scheme1_fttx_config_gen_1(hostname, tunnel_id, hub_vip, ap_admin_password, ap_ssid, ap_wifi_ip, ap_wifi_gateway)
+
+    [
+        "/system identity set name=#{hostname}",
+        "/ip dns set servers=134.17.1.0,134.17.1.1",
+        "/ip address add address=#{ap_wifi_ip} interface=ether1",
+        "/ip route add dst-address=0.0.0.0/0 gateway=#{ap_wifi_gateway}",
+        "/interface bridge add name=bridge_tunnel",
+        "/interface eoip add remote-address=#{hub_vip.to_s} tunnel-id=#{tunnel_id.to_s} name=tunnel_to_hub",
+        "/interface bridge port add interface=tunnel_to_hub bridge=bridge_tunnel",
+        "/interface bridge port add interface=wlan1 bridge=bridge_tunnel",
+        "/interface wireless set wlan1 mode=ap-bridge ssid=#{ap_ssid} disabled=no name=wireless_public_interface frequency=2427",
+        "/user set admin password=#{ap_admin_password}",
+        "/interface wireless set wlan2 disabled=yes"
+    ]
+
+  end
+
+end