Финальная версия скрипта
плюс я доработал библиотечку дописать пару строк оказалось проще )
кстати у вас возникнет проблема например то что для второй подсетки в вилане надо указывать secondary .. и надо будет эту ситуацию разрулить..
скрипт
Код:
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.StringTokenizer;
import bitel.billing.common.module.ipn.IPNContractStatus;
import bitel.billing.server.ipn.GateWorker;
import bitel.billing.server.ipn.UserStatus;
import ru.bitel.bgbilling.modules.ipn.server.bean.command;
//import ru.bitel.bgbilling.modules.ipn.server.bean.command.GateCommandUtil;
import ru.bitel.bgbilling.modules.ipn.server.bean.command.LoopPattern;
import bitel.billing.server.ipn.bean.VlanManager;
import bitel.billing.server.util.DefaultServerSetup;
import bitel.billing.server.util.Utils;
import bitel.billing.server.util.telnet.TelnetSession;
import ru.bitel.bgbilling.common.DefaultSetup;
import bitel.billing.common.IPUtils;
import bitel.billing.server.ipn.bean.GateType;
import bitel.billing.server.ipn.bean.RuleType;
import ru.bitel.bgbilling.modules.ipn.common.bean.AddressRangeManager;
import ru.bitel.common.Preferences;
includeBGBS( "bgbs://ru.bitel.bgbilling.kernel.script.common.bean.ScriptLibrary/gateCommandUtiltt" );
protected void doSync()
{
try
{
log.info( "start of cisco........................................................");
host = gate.getHost();
port = gate.getPort();
DefaultServerSetup gateSetup = new DefaultServerSetup( gate.getConfig(), "\r\n" );
pswdLogin = gateSetup.getStringValue("login");
pswdCfg = gateSetup.getStringValue( "cfg.pswd");
timeout = gateSetup.getIntValue( "timeout", 0 );
result = new StringBuffer();
if( log.isDebugEnabled() )
{
log.debug( gate.getId() + " gate: " + host + ":" + port + " pswdLogin: " + pswdLogin + " pswdCfg: " + pswdCfg );
}
log.info( "start of cisco......");
session = new TelnetSession( host, port);
session.setTimeout( timeout );
session.setLoginPromptSequence( ":" );
session.connect();
session.setLoginPromptSequence( ":" );
log.info( "log seq......" + pswdLogin);
result.append( session.doCommand( pswdLogin ) );
log.info( "login" );
session.setLoginPromptSequence( ">" );
log.info( "pass1" );
result.append( session.doCommand( pswdCfg ) );
log.info( "pass2" );
session.setLoginPromptSequence( ">" );
result.append( session.doCommand( "terminal length 0" ) );
result.append( session.doCommand( "terminal width 0" ) );
log.info( "term" );
session.setLoginPromptSequence( ":" );
result.append( session.doCommand( "enable" ) );
log.info( "en" );
session.setLoginPromptSequence( "#" );
result.append( session.doCommand( pswdCfg ) );
log.info( "pass" );
session.setLoginPromptSequence( "#" );
result.append( session.doCommand( "configure terminal" ) );
log.info( "conf" );
log.debug( "execute commands" );
doCommands( session, result);
log.info( "exec" );
result.append( session.doCommand( "exit" ) );
session.doCommandAsync( "exit" );
log.info("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
log.info( result );
log.info("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
log.debug( "ok" );
} catch (Exception e)
{
throw new RuntimeException ( e );
}
log.info( "end of cisco........................................................");
}
protected void add()
{
}
private void doCommands( TelnetSession session, StringBuffer result) throws IOException
{
for( UserStatus status : statusList )
{
date = new GregorianCalendar();
VlanManager manager = new VlanManager(status.mid, con);
gateId = gate.getId();
log.info("gateId=" + gateId);
vid = manager.getVlan( gateId, status.contractId );
log.info("vid=" + vid);
//TODO - подумать что сделать справилами на добавление
rules = null;
if (status.status == IPNContractStatus.STATUS_OPEN)
{
rules = getOpenRules( status, vid );
}
else if (status.status == IPNContractStatus.STATUS_REMOVED)
{
rules = getRemoveRules( status, vid );
}
//if closed and etc
else
{
rules = getCloseRules( status, vid);
}
if (vid > 0)
{
for ( String rule : rules )
{
result.append( session.doCommand( rule ) );
}
}
}
}
getOpenRules( status, vid )
{
return getRules( status, "\\[OPEN\\](.*)\\[/OPEN\\]", vid );
}
getCloseRules( status, vid )
{
return getRules( status, "\\[CLOSE\\](.*)\\[/CLOSE\\]", vid );
}
getRemoveRules( UserStatus status, int vid )
{
return getRules( status, "\\[REMOVE\\](.*)\\[/REMOVE\\]", vid );
}
getRules( status, template, vid )
{
// пользовательское правило, без типа - то все оставляем как есть
rule = status.rule.getRuleText();
log.info("rule=" + rule);
//типизированное правило
if( status.ruleType != null )
{
rule = generateRule( rule, status.gateType, status.ruleType, vid);
}
log.info("rule=" + rule);
pattern = Pattern.compile( template, Pattern.DOTALL );
m = pattern.matcher( rule );
if (m.find())
{
rule = m.group( 1 );
}
rule.replaceAll( "\r", "" );
parts = rule.split( "\n" );
result = new ArrayList();
for ( String part : parts )
{
if ( !Utils.isEmptyString( part ))
{
result.add( part );
}
}
return result;
}
generateRule( addresses, gateType, ruleType, int vid )
{
ruleText = getRule( gateType, ruleType );
replacements = new HashMap ();
if ( vid > 0)
{
replacements.put( "\\{VID\\}", String.valueOf( vid ) );
}
return generateRule( ruleText, addresses, replacements, ruleType);
}
Либа
Код:
private static StringBuffer processBlock( String ruleText, LoopPattern loopPattern )
{
StringBuffer result = new StringBuffer();
List items = new ArrayList( 10 );
Map letterMaxNumbers = new HashMap();
Pattern pattern = Pattern.compile( "\\{([A-Z]+)(\\d+)\\}" );
Matcher m = pattern.matcher( ruleText );
while( m.find() )
{
String letter = m.group( 1 );
int number = Utils.parseInt( m.group( 2 ), 0 );
PatternItem item = new PatternItem();
item.number = number;
item.letter = letter;
items.add( item );
Integer maxNumber = letterMaxNumbers.get( letter );
if( maxNumber == null || maxNumber < number )
{
letterMaxNumbers.put( letter, number );
}
}
final int size = loopPattern.getObjects().size();
for( int i = 0; i < size; i++ )
{
//String address = IPUtils.convertLongIpToString( Utils.parseLong( addreses[i], 0 ) );
String addressRule = new String( ruleText );
for( PatternItem item : items )
{
int number = i*(letterMaxNumbers.get( item.letter ) + 1) + item.number;
addressRule = addressRule.replaceAll(
"\\{" + item.letter + item.number + "\\}",
"{" + item.letter + number + "}" );
}
String str = addressRule;
for ( int j = 0; j < loopPattern.getReplacements().size(); j ++)
{
String key = loopPattern.getReplacements().get( j );
String value = loopPattern.getObjects().get( i ).get( j );
str = str.replaceAll( key, value );
}
result.append( str );
}
return result;
}
/**
* Формирует команды для шлюза.
* @param ruleText
* @param addressList
* @param replacements
* @param ruleType
* @return
*/
public static final String generateRule( String ruleText,
String addressList,
Map replacements,
RuleType ruleType )
{
List loops = getAddresLoops( addressList );
return generateRule( ruleText, replacements, ruleType, loops);
}
/**
* строку адреса преобразует в 2 LoopPattern-а : для диапазонов и сетей
* @param addressList
* @return
*/
public static List getAddresLoops( String addressList )
{
String[] parts = addressList.split( ";" );
List replacements = new ArrayList();
replacements.add ( "\\{A\\}" );
List objects = new ArrayList();
if ( parts.length > 0 && !Utils.isEmptyString( parts[0] ) )
{
String[] addrs = parts[0].split( "\\s*,\\s*" );
if ( addrs.length > 0)
{
for ( int i = 0; i < addrs.length; i++)
{
String address = IPUtils.convertLongIpToString( Utils.parseLongString( addrs[i], 0 ) );
log.info("address " + address);
List list = new ArrayList();
list.add( address );
objects.add( list );
}
}
}
List loops =new ArrayList();
//адреса
LoopPattern p = new LoopPattern();
p.setLoopPatern( "LOOP" );
p.setReplacements( replacements );
p.setObjects( objects );
loops.add( p );
replacements = new ArrayList();
replacements.add ( "\\{IP\\}" );
replacements.add ( "\\{MASK\\}" );
replacements.add ( "\\{MASK_WILD\\}" );
replacements.add ( "\\{MASK_BIT\\}" );
replacements.add ( "\\{GATE_IP\\}" );
objects = new ArrayList();
//String[] nets = new String [0];
//String[] net_masks = new String [0];
if ( parts.length > 1 && !Utils.isEmptyString( parts[1] ) )
{
String[] nets = parts[1].split( "\\s*,\\s*" );
if ( nets.length > 0)
{
for ( int i = 0; i < nets.length; i++)
{
String[] parts2 = nets[i].split( "/" );
if ( parts2.length == 2)
{
String address = IPUtils.convertLongIpToString( Utils.parseLongString( parts2[0], 0 ) );
String maskBit = parts2[1];
long mask = ( 0xFFFFFFFFl << ( 32 - Utils.parseIntString( maskBit, 0 ) ) ) & 0xFFFFFFFFl;
long maskWild = mask ^ 0xFFFFFFFFl;
List list = new ArrayList();
list.add( address );
list.add( IPUtils.convertLongIpToString( mask ) );
list.add( IPUtils.convertLongIpToString( maskWild ) );
list.add( maskBit );
list.add( IPUtils.convertLongIpToString( IPUtils.convertStringIPtoLong(address) + 1 ));
objects.add( list );
log.info("list " + list);
}
}
}
}
//сети
p = new LoopPattern();
p.setLoopPatern( "LOOP_NET" );
p.setReplacements( replacements );
p.setObjects( objects );
loops.add( p );
return loops;
}
/**
* Формирует команды для шлюза.
* @param ruleText
* @param replacements
* @param ruleType
* @param loops
* @return
*/
public static final String generateRule( String ruleText,
Map replacements,
RuleType ruleType,
List loops)
{
StringBuffer resultBuf = null;
for ( LoopPattern loop : loops)
{
resultBuf = new StringBuffer();
String loopPattern = "(<LOOP>.*?</LOOP>)?(.*?)<LOOP>(.*?)</LOOP>";
loopPattern = loopPattern.replaceAll( "LOOP", loop.getLoopPatern() );
Pattern pattern = Pattern.compile( loopPattern, Pattern.DOTALL );
Matcher m = pattern.matcher( ruleText );
boolean find = false;
while( m.find() )
{
find = true;
String block = m.group( 3 );
block = processBlock( block, loop ).toString();
resultBuf.append( m.group( 2 ) );
resultBuf.append( block );
}
if (find)
{
//хвост(ищем жадным алгоритмом) или если вообще нет ни одного цикла
loopPattern = "(?:<LOOP>(?:.*)</LOOP>)(.*)\\z";
loopPattern = loopPattern.replaceAll( "LOOP", loop.getLoopPatern() );
pattern = Pattern.compile( loopPattern, Pattern.DOTALL );
m = pattern.matcher( ruleText );
if( m.find() )
{
resultBuf.append( m.group( 1 ) );
}
}
else
{
resultBuf = new StringBuffer( ruleText );
}
//пошли по второму и т.п заходу
ruleText = resultBuf.toString();
}
String result = resultBuf.toString();
result = result.replaceAll( "<ver 2\\.0/>", "" );
//убиваем пустые строки
result = result.replaceAll( "\r", "" );
result = result.replaceAll( "\n\\s*\n", "\n" );
result = result.replaceAll( "(\n){2,}", "\n" );
result = result.trim();
String ruleData = ruleType.getData();
ruleData.replaceAll( "\r", "\n" );
ruleData = ruleData.trim();
Preferences setup = new DefaultSetup( ruleData, "\n");
//получаем все значения
Map values = setup.getHashValuesWithPrefix( "" );
if( replacements == null)
{
replacements = new HashMap();
}
for (Map.Entry entry : values.entrySet())
{
String key = "\\$\\{" + entry.getKey() + "\\}";
replacements.put( key, entry.getValue() );
}
if (replacements != null)
{
for (Map.Entry rep : replacements.entrySet())
{
//result = result.replaceAll( "\\{CID\\}", String.valueOf( cid ) );
result = result.replaceAll( rep.getKey(), rep.getValue() );
}
}
return result.toString();
}
private static class PatternItem
{
public String letter;
public int number;
}
/**
* Получает команды для шлюза в непереработанном виде.
* @param gateType
* @param ruleType
* @return
*/
public static String getRule( GateType gateType, RuleType ruleType )
{
String result = "";
String template = "\\[RULE ID=\"((?:\\d+,*)+)\"\\](.*?)\\[/RULE\\]";
Pattern pattern = Pattern.compile( template, Pattern.DOTALL );
Matcher m = pattern.matcher( gateType.getRule() );
while( m.find() )
{
String idsStr = m.group(1);
String rule = m.group( 2 );
int[] ids = parseIds( idsStr );
for (int i = 0; i < ids.length; i++)
{
if (ruleType.getId() == ids [i] )
{
return rule;
}
}
}
//default
template = "\\[DEFAULT\\](.*)\\[/DEFAULT\\]";
pattern = Pattern.compile( template, Pattern.DOTALL );
m = pattern.matcher( gateType.getRule() );
if( m.find() )
{
String rule = m.group( 1 );
return rule;
}
return result;
}
private static int[] parseIds( String idsStr )
{
String[] strs = idsStr.split( "," );
int[] result = new int [strs.length];
for (int i = 0; i < strs.length; i++)
{
result[i] = Integer.parseInt( strs[i]);
}
return result;
}
Вход
Регистрация
FAQ
Поиск
