Cuatro ciudadanos colombianos que fueron detenidos por microtráfico de drogas en allanamiento de siete domicilios que realizó de madrugada este viernes personal del OS-7 de Carabineros en la villa Alto Aconcagua en Los Andes, serán expulsados del país al constatarse que estos se encontraban de forma ilegal en territorio nacional. (Foto: A las 06:30 horas OS-7 de Carabineros con amplio apoyo del GOPE desplegaron operativo en villa Alto Aconcagua)
El Capitán Felipe Maureira, jefe del OS-7 de Carabineros de la Prefectura de Aconcagua, comentó que el masivo operativo que contó con apoyo de personal del GOPE de Valparaíso, se realizó a las 06:30 horas de este viernes en la villa Alto Aconcagua, concretándose el allanamiento de siete domicilios, tras una investigación que se venía desarrollando de hace tres meses; “lográndose desbaratar una red de microtráfico organizada por ciudadanos de nacionalidad colombiana y que operaba en esta villa en la ciudad de Los Andes. Un sector bastante complejo y que estaba un poco marcado para los vecinos por el fuerte microtráfico que se está dando por ciudadanos colombianos.”
Con antecedentes reunidos en la respectiva investigación y las autorizaciones de tribunales, personal del OS-7 de Carabineros planificó el operativo desplegado a primera hora de este viernes; “con el objeto de hacer un allanamiento de siete domicilios, lográndose en esta diligencia la incautación de marihuana, pasta base y clorhidrato de cocaína, que en su totalidad podrían haber llegado a las mil dosis y generar una ganancia por sobre el millón de pesos.”
“Si bien la cantidad drogas incautadas no son tan altas, el efecto que esta detenciones que originan en los vecinos de este sector de la ciudad de Los Andes, es muy importante.”-puntualizó Maureira.
El oficial de Carabineros señaló en este procedimiento hubo cuatro hombres detenidos de nacionalidad colombiana; “los que se pudo comprobar que estaban ilegales en el país y deberán ser expulsados del territorio nacional en las próximas horas.”
Maureira precisó que la villa Alto Aconcagua enfrenta diversas problemáticas con la llegada masiva de ciudadanos colombianos; “efectivamente hay un alto índice de estos migrantes que mantienen residencia, pero también hay algunos que están cometiendo ilícitos y la idea de la investigación desarrollada tenía como objetivo identificar a estos sujetos y ponerlos a disposición de los tribunales.”
El OS-7 continuará con algunas diligencias en torno l caso; “porque quedan algunas investigación en curso.
Excelente resolución…eso debería tomarse con cualquier extranjero que cometa un delito en Chile…!!! ya que viven en nuestro país de allegado…!!!
Es lo mejor que se puede hacer todo extranjero que cometa un delito de cualquier indole,tiene que ser EXPULSADO de inmediato.
?Customized facts walkthrough
Custom made facts
Prolong Facter by producing your individual customized facts to produce information and facts to Puppet.
Adding tailor made facts to Facter
Usually you would like to be able to put in writing conditional expressions dependant on site-specific information that just isnвЂ™t on hand by way of Facter, or perhaps youвЂ™d like to include it inside a template.
Since you canвЂ™t include arbitrary Ruby code within your manifests, the right answer is to insert a new fact to Facter. These increased facts can then be distributed to Puppet clients and are accessible for use in manifests and templates, just like any other fact would be.
Note: Facter 3.0 removed the Ruby implementations of some qualities and replaced them using a personalized facts API. Any custom made fact that requires an individual from the Ruby data files previously stored in lib/facter/util will fail with the error. For a good deal more specifics, see the Facter 3.0 release notes .
You’ll insert new facts by crafting snippets of Ruby code within the Puppet master. Puppet then utilizes Plugins in Modules to distribute the facts to the client.
Loading personalized facts
Facter gives several methods of loading facts:
$LOAD\_PATH. or the Ruby library load path
The –custom-dir command line option.
The environment variable вЂFACTERLIBвЂ™
You can still use these methods of loading facts to do things like take a look at data files locally before distributing them, otherwise you can arrange to have a specified list of facts around on certain machines.
Utilizing the Ruby load path
Facter searches all directories inside of the Ruby $LOAD_PATH variable for subdirectories named вЂfacterвЂ™, and loads all Ruby information in those directories. When you had some directory with your $LOAD_PATH like
/lib/ruby. arrange like this:
Facter would try to load вЂfacter/system_load.rbвЂ™, вЂfacter/users.rbвЂ™, and вЂfacter/rackspace.rbвЂ™.
Making use of the –custom-dir command line option
Facter can take a variety of –custom-dir solutions to the command line that specifies only one directory to search for custom made facts. Facter attempts to load all Ruby documents within the specified directories. This makes it possible for you to definitely do something like this:
Employing the FACTERLIB environment variable
Facter also checks the environment variable FACTERLIB for a delimited (semicolon for Windows and colon for all other platforms) list of directories, and tries to load all Ruby documents in those directories. This makes it possible for you to definitely do something like this:
Note: Changes in built-in pluginsync help in Facter 3
Facter two.four deprecated FacterвЂ™s help for loading facts through PuppetвЂ™s pluginsync (the -p option), and Facter 3.0.0 removed the -p option. However, we reversed this decision in Facter 3.0.two and re-enabled the -p option. For details about present and long term help for this option, see the Facter 3.0.two release notes .
Two parts of every fact
Setting aside external facts for now, most facts have at least two components:
A call to Facter.include(‘fact_name’). which determines the name in the fact
A setcode statement for easy resolutions, which is evaluated to determine the factвЂ™s value.
Facts can get a lot added complicated than that, but those two together are probably the most general implementation of the custom made fact.
Executing shell commands in facts
Puppet gets important information about a model from Facter, as well as most everyday way for Facter to get that particulars is by executing shell commands. You can actually then parse and manipulate the output from those commands by making use of standard Ruby code. The Facter API gives you a handful of ways to execute shell commands:
If all you ought to do is run the command and make use of the output, verbatim, as your factвЂ™s value, youвЂ™re able to pass the command into setcode directly. For example: setcode ‘uname –hardware-platform’
If your fact is added complicated than that, you possibly can call Facter::Core::Execution.exec(‘uname –hardware-platform’) from inside the setcode do вЂ¦ conclude block. As always, whatever the setcode statement returns is put into use given that the factвЂ™s value.
In any case, remember that your shell command can also be a Ruby string, so youвЂ™ll will be needing to escape special characters for those who desire to pass them through.
It is important to note that not everything that will work during the terminal will deliver the results inside of a fact . You will utilize the pipe ( | ) and similar operators as you normally would, but Bash-specific syntax like if statements will not do the job. The most useful way to handle this limitation is to jot down your conditional logic in Ruby.
LetвЂ™s say you may need to get the output of uname –hardware-platform to one out a exact type of workstation. To do this, you would develop a new tailor made fact. Launch by giving the fact a name, within this case, hardware_platform. and generate your new fact inside a file, hardware_platform.rb. relating to the Puppet master server:
You can actually then make use of the instructions while in the Plugins in Modules webpage to copy the new fact to the module and distribute it. During your next Puppet run, the value on the new fact will be on the market to make use of into your manifests and templates.
Making use of other facts
You can still publish a fact that utilizes other facts by accessing Facter.value(:somefact). If the fact fails to resolve or shouldn’t be current, Facter returns nil .
Facts have one or two properties that you simply can use to customize how facts are evaluated.
Just one from the extra commonly utilised properties is the confine statement, which restricts the fact to only run on solutions that matches another given fact.
An example for the confine statement would be something like the following:
This fact works by using sysfs on linux to get a list belonging to the power states that are on hand about the given scheme. Since this is only on the market on Linux solutions, we utilize the confine statement to ensure that this fact isnвЂ™t needlessly run on devices that really do not help this type of enumeration.
One fact can have many different resolutions . every of which is truly a different way of ascertaining what the value within the fact should be. It is very frequent to have different resolutions for different operating solutions, for example. It is trouble-free to confuse facts and resolutions on the grounds that they are superficially identical – to include a new resolution to some fact, you simply insert the fact again, only accompanied by a different setcode statement.
When a fact has in excess of a single resolution, the to start with resolution that returns a value other than nil will established the factвЂ™s value. The way that Facter decides the issue of resolution precedence is the weight property. Once Facter rules out any resolutions that are excluded when you consider that of confine statements, the resolution with the highest weight is evaluated very first. If that resolution returns nil. Facter moves on to the next resolution (by descending weight) until it gets a value for your fact.
By default, the weight of the fact is the selection of confines for that resolution, so that alot more particular resolutions takes priority over less precise resolutions.
Facter two.x supported a :timeout option to Facter#add. Facter no longer supports this option, and produces a warning if it is put into use.
Although this version of Facter does not service overall timeouts on resolutions, you can actually pass a timeout to Facter::Core::Execution#execute :
Despite the fact that the norm is for a fact to return only one string, Facter two.0 introduced structured facts . which take the kind of either a hash or an array. All you would like to do to produce a structured fact is return a hash or an array from the setcode statement. You can easlily see some relevant examples inside the creating structured facts section of your Fact Overview .
If your fact brings together the output of a few different commands, it may make perception to utilise aggregate resolutions . An aggregate resolution is split into вЂњchunksвЂќ, every a person responsible for resolving just one piece from the fact. After all within the chunks have been resolved separately, theyвЂ™re combined into only one flat or structured fact and returned.
Aggregate resolutions have several key differences compared to easy to understand resolutions, beginning with the fact declaration. To introduce an aggregate resolution, youвЂ™ll really need to insert the :type => :aggregate parameter:
Each individual step inside the resolution then gets its private named chunk statement:
Inside a quick resolution, the code always incorporates a setcode statement that determines the factвЂ™s value. Aggregate resolutions never have a setcode statement. Instead, they have an optional aggregate block that brings together the chunks. Whatever value the aggregate block returns will be the factвЂ™s value. HereвЂ™s an example that just brings together the strings from the two chunks higher than:
If the chunk blocks either all return arrays or all return hashes, it’s possible to omit the aggregate block. Any time you do, Facter quickly merges all of your information into 1 array or hash and use that as being the factвЂ™s value.
For added examples of aggregate resolutions, see the aggregate resolutions section in the Fact Overview web site.
Viewing fact values
If your Puppet master(s) are configured to try PuppetDB. you are able to perspective and search all on the facts for any node, which includes custom made facts. See the PuppetDB docs for a good deal more info.
What are external facts?
External facts deliver a way make use of arbitrary executables or scripts as facts, or established facts statically with structured knowledge. If youвЂ™ve ever wanted to write down a customized fact in Perl, C, or a one-line textual content file, this is how.
The highest quality way to distribute external facts is with pluginsync, which included help for them in Puppet 3.four /Facter two.0.1. To increase external facts to your Puppet modules, just site them in <MODULEPATH>/<MODULE>/facts.d/ .
If youвЂ™re not choosing pluginsync, then external facts must go in a very standard directory. The location of this directory varies contingent on your operating model, whether your deployment utilizes Puppet Company or open source releases, and whether you will be operating as root/Administrator. When calling facter from the command line, you may specify the external facts directory with the –external-dir option.
Note: These directories really do not necessarily exist by default; you may would need to develop them. Should you build the directory, make sure to restrict accessibility so that only Administrators can create to the directory.
In a very module (recommended):
On Unix/Linux/OS X, there are three directories:
On Windows 2003:
When operating as a non-root / non-Administrator person:
Executable facts – Unix
Executable facts on Unix job by dropping an executable file into the standard external fact path earlier mentioned. A shebang is always required for executable facts on Unix. If the shebang is missing, the execution for the fact will fail.
An example external fact written in Python:
You must ensure that the script has its execute bit established:
For Facter to parse the output, the script must return key/value pairs on STDOUT during the format:
Utilising this format, an individual script can return a variety of facts.
Executable facts – Windows
Executable facts on Windows function by dropping an executable file into the external fact path for your personal version of Windows. Unlike with Unix, the external facts interface expects Windows scripts to conclude by having a known extension. Line endings could be either LF or CRLF. With the moment the following extensions are supported:
.com and .exe. binary executables
.bat and .cmd. batch scripts
.ps1. PowerShell scripts
As with Unix facts, each and every script must return key/value pairs on STDOUT inside of the format:
Applying this format, only one script can return many facts in a single return.
The file encoding for .bat/.cmd documents must be ANSI or UTF8 without BOM (Byte Order Mark), otherwise you may get strange output.
Right here is mostly a sample batch script which outputs facts working with the required format:
The encoding that should be applied with .ps1 data files is pretty open. PowerShell determines the encoding from the file at run time.
Below is actually a sample PowerShell script which outputs facts utilising the required format:
You should be able to save and execute this PowerShell script for the command line.
Structured details facts
Facter can parse structured facts data files stored during the external facts directory and established facts influenced by their contents.
Structured details data files must use a single for the supported information forms and must have the correct file extension. With the moment, Facter supports the following extensions and info kinds:
yaml. YAML information, inside the following format:
json. JSON facts, while in the following format:
txt. Key value pairs, with the following format:
As with executable facts, structured information documents can established different facts at once.
Structured facts facts on Windows
All belonging to the higher than variations are supported on Windows with the following caveats:
The line endings can certainly be either LF or CRLF .
The file encoding must be either ANSI or UTF8 without BOM (Byte Order Mark).
If your external fact isn’t really appearing in FacterвЂ™s output, functioning Facter in debug mode should give you a meaningful reason and tell you which file is causing the problem:
A single example of when this would happen is in cases where a fact returns invalid characters. Let say you utilised a hyphen instead of an equals sign on your script check.sh :
Functioning puppet facts –debug should yield a useful message:
External facts and stdlib
If you should get hold of that an external fact does not match what you have configured inside your facts.d directory, make sure you haven’t defined the same fact by making use of the external facts abilities found with the stdlib module.
Whilst external facts offer a mostly-equal way to make variables for Puppet, they have one or two disadvantages:
An external fact cannot internally reference another fact. However, due to parse order, it is possible to reference an external fact from the Ruby fact.
External executable facts are forked instead of executed in just the same strategy.
Distributing executable facts through pluginsync requires Puppet 3.four.0 or greater.